Can a class-interface design from Python be mirrored in Rust? - class

Question

A pattern I use frequently when writing Python is using class-only designs. I'll create an abstract base class, consisting of only classmethod and staticmethod methods. From this base, I can derive subclasses with specialized behavior for these methods. Since each of these subclasses have the same interface, and don't have any instance methods, I can pass around the classes themselves to client code, as opposed to instances of those classes.
As a simple, yet real/relevant example, here's how I would tackle needing to support multiple file formats for config data:
import abc
import yaml
import json
class ConfigReader(abc.ABC):
#classmethod
def from_file_path(cls, path: str):
with open(path) as fo:
return cls.from_string(fo.read())
#classmethod
#abc.abstractmethod
def from_string(cls, s: str):
pass
class YamlConfigReader(ConfigReader):
#classmethod
def from_string(cls, s: str):
return yaml.load(s)
class JsonConfigReader(ConfigReader):
#classmethod
def from_string(cls, s: str):
return json.loads(s)
Client code can then use the classes themselves in lieu of instances of those classes to do config parsing:
import typing as tp
def read_config_file(path: str, config_reader: tp.Type[ConfigReader]):
return config_reader.from_file_path(path)
print(read_config_file('config.yaml', YamlConfigReader))
print(read_config_file('config.json', JsonConfigReader))
I'm trying to do something similar to the above in Rust, but I seem to be running into issues. My initial approach used traits and associated methods:
use std::path::Path;
use std::fs::File;
use std::io::Read;
use std::io::Error;
pub trait ConfigReader {
fn from_str<S: AsRef<str>>(s: S) -> Result<String, Error>;
fn from_file<P: AsRef<Path>>(p: P) -> Result<String, Error> {
let p = p.as_ref();
let mut f = File::open(p)?;
let mut buffer = String::new();
f.read_to_string(&mut buffer)?;
Self::from_str(buffer)
}
}
pub struct YamlConfigReader;
pub struct JsonConfigReader;
impl ConfigReader for YamlConfigReader {
fn from_str<S: AsRef<str>>(_s: S) -> Result<String, Error> {
Ok("dummy".to_string())
}
}
impl ConfigReader for JsonConfigReader {
fn from_str<S: AsRef<str>>(_s: S) -> Result<String, Error> {
Ok("dummy".to_string())
}
}
fn read_config_file<P: AsRef<Path>>(p: P, config_reader: &ConfigReader) -> Result<String, Error> {
config_reader.from_file(p)
}
fn main() {}
(playground)
This gives me the error:
error[E0038]: the trait `ConfigReader` cannot be made into an object
--> src/main.rs:37:1
|
37 | fn read_config_file<P: AsRef<Path>>(p: P, config_reader: &ConfigReader) -> Result<String, Error> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `ConfigReader` cannot be made into an object
|
= note: method `from_str` has no receiver
= note: method `from_file` has no receiver
Is this sort of pattern possible in Rust? If not, what are some ways I can emulate this sort of behavior of decoupled, modular, stateless interfaces?

Answer 1

In Rust, you would treat a type parameter as, well, a type parameter:
fn read_config_file<P: AsRef<Path>, C: ConfigReader>(p: P) -> Result<String, Error> {
C::from_file(p)
}
This limits the dynamisms of such constructs.