Is it possible to compose a chain of functions at runtime? - rust

Question

I have 3 functions:
fn f1() -> u64 {
println!("Hello world: 1");
2
}
fn f2(i: u64) -> Box<FnMut()> {
println!("Hello world: {}", i);
Box::new(|| println!("Hello world: {}", 3))
}
fn f3(mut f: Box<FnMut()>) {
f()
}
One functional technique is chaining — connecting the output of function A to the input of function B:
fn main() {
f3(f2(f1()));
}
This may help in Rust because this method is purely functional and the functions can be pure functions; they don't touch global variables, only work with its arguments which were moved (which is awesome).
How can I do this chain at runtime? If I have function f4 which accepts the input of f2 but does not use it as f3. We can also use it for further chaining by adding a return type to it:
fn f4(_: Box<FnMut()>) -> bool {
println!("Hello world: 4");
true
}
fn main() {
f4(f2(f1())) // returns f4's result (true)
}
I want to be able to decide how to chain my functions at runtime. The example would be this Lua code (sorry for this):
function f1()
print("Hello world: 1")
return 2
end
function f2(args)
print("Hello world: " .. args)
return function()
print("Hello world: " .. args + 1)
end
end
function f3(args)
args()
end
function f4()
print("Hello world: 4")
end
function run_chain(list)
local args
for _, v in ipairs(list) do
args = v(args)
end
end
local list = {}
list[#list + 1] = f1
list[#list + 1] = f2
list[#list + 1] = f3
run_chain(list)
list[#list] = f4
run_chain(list)
This is a big plus of dynamic typing of scripting languages, but as far as I know Rust alleges that it is much more functional than C++ for example. Is it possible to chain the functions in such a way?

Answer 1

Here's how you can do the simple chaining issue. Converting it from free functions to a builder or operator style is left as an exercise. It also uses the "impl Trait" feature introduced in Rust 1.26 to make it nicer.
fn f1(_: ()) -> u64 {
println!("Hello world: 1");
2
}
fn f2(i: u64) -> Box<FnMut()> {
println!("Hello world: {}", i);
Box::new(|| println!("Hello world: {}", 3))
}
fn f3(mut f: Box<FnMut()>) {
f()
}
fn f4(_: Box<FnMut()>) -> bool {
println!("Hello world: 4");
true
}
fn dot<I, X, O, F1, F2>(mut f1: F1, mut f2: F2) -> impl FnMut(I) -> O
where
F1: FnMut(I) -> X,
F2: FnMut(X) -> O,
{
move |i| f2(f1(i))
}
fn main() {
let mut c = dot(dot(f1, f2), f3);
c(());
let mut c2 = dot(dot(f1, f2), f4);
c2(());
}
Playground
Gluing two functions together is not very hard, but you may run into lifetime issues if your types are more complex. In particular, if the input parameter to a function in the chain is a reference to the type that the previous function returns, this code will not compile. I believe that some more parameters and generic bounds can solve this issue, but you would have to experiment a bit.
See also the tool crate (compose is pretty much what I just posted) and the rustz crate, both of which add more functional idioms to Rust.

Answer 2

Edit: This answer is for the question as I originally understood it. The chaining comment at the end makes this answer not ideally; that's a different beast. The answer to that is, yes, it's possible, but like any metaprogramming not easy.
Not well, but this has nothing to do with being functional or not. It's about typing.
You can do this in Rust:
struct Chain {
f1: Box<FnMut() -> u64>,
f2: Box<FnMut(u64) -> Box<FnMut()>>,
f3: Box<FnMut(Box<FnMut()>)>,
}
impl Chain {
fn run(&self) {
f3(f2(f1()));
}
}
fn f1() -> u64 {
println!("Hello world: 1");
2
}
fn f2(i: u64) -> Box<FnMut()> {
println!("Hello world: {}", i);
Box::new(|| println!("Hello world: {}", 3))
}
fn f3(mut f: Box<FnMut()>) {
f()
}
fn main() {
let chain = Chain {
f1: Box::new(f1),
f2: Box::new(f2),
f3: Box::new(f3),
};
chain.run();
}
But you can't append arbitrary functions to this chain, nor can you substitute f4 for f3:
error[E0271]: type mismatch resolving `<fn(std::boxed::Box<std::ops::FnMut() + 'static>) -> bool {f4} as std::ops::FnOnce<(std::boxed::Box<std::ops::FnMut() + 'static>,)>>::Output == ()`
--> src/main.rs:36:13
|
36 | f3: Box::new(f4),
| ^^^^^^^^^^^^ expected bool, found ()
|
= note: expected type `bool`
found type `()`
= note: required for the cast to the object type `std::ops::FnMut(std::boxed::Box<std::ops::FnMut() + 'static>)`
Because Rust is strictly typed, the functions in the chain have to be of known types, and those types have to fit together.
That said, anything a dynamic language can do, Rust can emulate if you just implement enough of the dynamic typing machinery yourself. You can make a struct that contains a Vec<Box<FnMut(&Any) -> Any>> and an add_func generic method that takes some function and adds a wrapper that does the necessary unwrapping, checking and rewrapping to the Vec. The run method then calls these functions in order.

Answer 3

I have actually done this I think. This code may need some review, but I think everything can be implement in the following way:
Define the functions you wanna call:
fn f1() -> u64 {
println!("Hello world: 1");
2
}
fn f2(i: u64) -> Box<FnMut()> {
println!("Hello world: {}", i);
Box::new(|| println!("Hello world: {}", 3))
}
fn f3(mut f: Box<FnMut()>) {
f()
}
fn f4(_: Box<FnMut()>) -> bool {
println!("Hello world: 4");
true
}
Take the advantage of having Any type in Rust type system as same as closures:
use std::any::Any;
struct Bridge<'a> {
function: &'a mut FnMut(Box<Any>) -> Box<Any>,
}
The closures can then be used for type erasure of called functions. However, we would still need some work in function checking arguments:
fn run_chain(chain: &mut [Bridge]) -> Box<Any> {
if chain.is_empty() {
return Box::new(false)
}
let mut args;
{
let function = &mut chain.first_mut().unwrap().function;
args = function(Box::new(0));
}
for c in chain.iter_mut().skip(1) {
let res = (c.function)(args);
args = res;
}
args
}
fn main() {
let mut f1 = |_: Box<Any>| { let res = f1(); Box::new(res) as Box<Any> };
let mut f2 = |args: Box<Any>| { let res = f2(*args.downcast::<u64>().unwrap()); Box::new(res) as Box<Any> };
let mut f3 = |args: Box<Any>| { let res = f3(*args.downcast::<Box<FnMut()>>().unwrap()); Box::new(res) as Box<Any> };
let mut f4 = |args: Box<Any>| { let res = f4(*args.downcast::<Box<FnMut()>>().unwrap()); Box::new(res) as Box<Any> };
let mut fns: Vec<Bridge> = Vec::new();
fns.push(Bridge { function: &mut f1 });
fns.push(Bridge { function: &mut f2 });
fns.push(Bridge { function: &mut f3 });
let _ = run_chain(&mut fns);
fns.pop();
fns.push(Bridge { function: &mut f4 });
let res = run_chain(&mut fns);
println!("Result: {:?}", res.downcast::<bool>().unwrap());
}
So basically all we do is writing a closure wrapper with the same interface. The type checking can be done right inside the closure before passing the argument further and it can be checked so that it will not lead to a crash.