currycompose

一个提供执行Rust中currying（以及非currying）函数组合特质的crate。

A可以与B组合，如果A实现了FnOnce并接受一个或多个参数，而B实现了FnOnce并返回与A的第一个参数相同类型的值。

• 例如，(A, B) -> Y可以与(C) -> A组合，产生(B, C) -> Y（currying）。

• 将(A, B) -> Y与(C) -> A然后与(D) -> B组合产生(C, D) -> Y（currying两次）。

• 当然，(A) -> Y与(B) -> A组合，会产生(B) -> Y，正如预期的那样（非currying组合）。

实现FnMut或Fn的currying函数将产生也实现FnMut/Fn的值，如果两个操作数都这样做。

lib.rs:

https://en.wikipedia.org/wiki/Function_composition

一个提供执行Rust中currying（以及非currying）函数组合特质的crate。

非currying组合：h(x) = g ∘ f = g(f(x))

currying组合：h(..., x) = g ∘ f = g(f(x), ...)

在currying时，被currying的函数的参数会被移动到参数列表的末尾

两个操作数都必须实现FnOnce。如果两个操作数都实现了FnMut或Fn，则产生的组合也将实现这些特性。

g也必须有一个或多个参数，其中第一个参数的类型等于f的返回类型。

#![feature(generic_const_exprs)]

use currycompose::*;

// g ∘ f
// where
// g :: f32 -> f32
// f :: u8 -> f32
// g ∘ f :: u8 -> f32
let g = |x: f32| x*x;
let f = |x: u8| x as f32;

let gf = g.compose(f);

let x = 1;

assert_eq!(gf(x), g(f(x)));

// g ∘ f
// where
// g :: f32 -> f32 -> f32
// f :: u8 -> f32
// g ∘ f :: f32 -> u8 -> f32
let g = |x: f32, y: f32| x + y;
let f = gf;

let gf = g.compose(f);

let x = 1;
let y = 1.0;

// note here the argument x has been shifted to the end of the args in gf
assert_eq!(gf(y, x), g(f(x), y));

// g ∘ f ∘ f
// where
// g :: f32 -> f32 -> f32
// f :: u8 -> f32
// g ∘ f ∘ f :: u8 -> u8 -> f32
let gff = gf.compose(f);

let x = 1;
let y = 1;

assert_eq!(gff(x, y), g(f(x), f(y)));