main
annieversary 2022-01-19 21:14:40 +00:00
parent bf8cdab3b8
commit ee90435633
1 changed files with 125 additions and 93 deletions

View File

@ -1,11 +1,79 @@
* effers * effers
** implementation details effect handlers in rust
we could do something with proc macros maybe?
where like, it scans through the tagged function, then it generates like a type? ** how to use
then that type you can call a function that provides it an effect runner *** defining effects
effects are defined with traits
#+begin_src rust #+begin_src rust
// the `Smth =>` part is optional trait Printer {
fn print(&mut self, s: &str);
}
trait Logger {
fn debug(&mut self, s: &str);
fn info(&mut self, s: &str);
}
#+end_src
all the trait functions (that are used in programs) must take ~&mut self~ as a parameter
*** defining a program
programs are defined as a normal function, with the added ~program~ attribute
#+begin_src rust
#[program(Smth => Printer(print as p), Logger(debug, info))]
fn smth(val: u8) -> u8 {
p("hey hi hello");
debug("this is a debug-level log");
info("this is a info-level log");
val + 3
}
#+end_src
the first token (~Smth~) will be the name of the program. effects are listed after the ~=>~ token
**** listing effects
effects are listed by writing the trait's name, followed by a parenthesized list of the functions that will be used
functions can be given an alias using the ~as~ keyword
*** defining effect handlers
effect handlers are defined by declaring a struct, and implementing the trait on it
#+begin_src rust
struct IoPrinter;
impl Printer for IoPrinter {
fn print(&mut self, s: &str) {
println!("{}", s)
}
}
struct FileLogger;
impl Logger for FileLogger {
fn debug(&mut self, s: &str) {
println!("debug: {}", s)
}
fn info(&mut self, s: &str) {
println!("info: {}", s)
}
}
#+end_src
*** running programs
programs are run by providing the corresponding handlers in order, and finally calling the ~run~ method, providing it the required parameters
#+begin_src rust
let result: u8 = Smth.add(IoPrinter).add(FileLogger).run(3);
assert_eq!(result, 6);
#+end_src
** full example
#+begin_src rust
use effers::program;
#[program(Smth => Printer(print as p), Logger(debug, info))] #[program(Smth => Printer(print as p), Logger(debug, info))]
fn smth(val: u8) -> u8 { fn smth(val: u8) -> u8 {
p("hey hi hello"); p("hey hi hello");
@ -18,94 +86,58 @@ then that type you can call a function that provides it an effect runner
fn main() { fn main() {
// maybe smth like this? // maybe smth like this?
let result: u8 = Smth let result: u8 = Smth.add(IoPrinter).add(FileLogger).run(3);
.add(IoPrinter) assert_eq!(result, 6);
.add(FileLogger)
.run(3);
let other_result: u8 = Smth let other_result: u8 = Smth
.add(IoPrinter) .add(IoPrinter)
.add(NetworkLogger { .add(NetworkLogger {
credentials: "secret password".to_string() credentials: "secret password".to_string(),
}) })
.run(3); .run(8);
assert_eq!(other_result, 11);
} }
// effects
trait Printer { trait Printer {
fn print(); fn print(&mut self, s: &str);
} }
trait Logger { trait Logger {
fn debug(&mut self); fn debug(&mut self, s: &str);
fn info(&mut self); fn info(&mut self, s: &str);
} }
struct IoPrinter; struct IoPrinter;
impl Printer for IoPrinter { impl Printer for IoPrinter {
fn print(s: &str) { println!(s) } fn print(&mut self, s: &str) {
println!("{}", s)
}
} }
struct FileLogger; struct FileLogger;
impl Logger for FileLogger { impl Logger for FileLogger {
fn debug(&mut self) { ... } fn debug(&mut self, s: &str) {
fn info(&mut self) { ... } println!("debug: {}", s)
}
fn info(&mut self, s: &str) {
println!("info: {}", s)
}
} }
struct NetworkLogger { credentials: String } struct NetworkLogger {
credentials: String,
}
impl Logger for NetworkLogger { impl Logger for NetworkLogger {
fn debug(&mut self) { ... } fn debug(&mut self, s: &str) {
fn info(&mut self) { ... } println!(
"debug through network: {}; with password {}",
s, self.credentials
)
} }
#+end_src fn info(&mut self, s: &str) {
println!(
the macro will substitute the function to: "info through network: {}; with password {}",
s, self.credentials
#+begin_src rust )
struct Smth;
struct SmthWithPrinter<P: Printer>(Smth, P);
struct SmthWithPrinterLogger<P: Printer, L: Logger>(Smth, P, L);
impl Smth {
fn add<P: Printer>(self, p: P) -> SmthWithPrinter<P> {
SmthWithPrinter(self, p)
}
}
impl<P: Printer> SmthWithPrinter<P> {
fn add<L: Logger>(self, l: L) -> SmthWithPrinterLogger<P, L> {
SmthWithPrinterLogger(self.0, self.1, l)
}
}
impl<P: Printer, L: Logger> SmthWithPrinterLogger<P, L> {
fn run(self, val: u8) -> u8 {
let l = self.2; // we probably don't do this though, just do an actual replacement
P::print("hey hi hello");
l.debug("this is a debug-level log");
l.info("this is a info-level log");
3
} }
} }
#+end_src #+end_src
this could be rewritten to allow users to take any path when writing adding the effect handlers
maybe not, cause we might want to have two of the same kind of effect, which would make us unable to tell them apart
we can then make macros that make declaring an effect easier ig
** questions
*** DONE how to pass the logger into the function
CLOSED: [2022-01-18 Tue 19:41]
an option is to add it to the list of params
*** DONE how to make it so the user can't call it directly
CLOSED: [2022-01-18 Tue 19:41]
solved, the function lives inside an impl block for a type
*** TODO can we make it so it's uses ~IoPrinter::print~ instead of ~io_printer.print~?
cause that would have better performance i think?
cause it's just a static function and that's known at comp time
with the other it does dynamic dispatch
idk if we have access to that info on the macro
*** TODO how to deal with multiple of the same type of effect
i think it Just Works if we keep the order thing. we just have to make sure they define different names in the macro invocation, otherwise we won't know which one to use
https://hackage.haskell.org/package/effet this uses tags