orx_closure

显式闭包，将捕获的数据与函数绝对分离。

为什么

它旨在解决通过 fn_traits 使用常规闭包时观察到的一些问题，例如

• 没有充分理由就要对闭包进行装箱，
• 没有充分理由就要向包含闭包的结构体添加泛型参数，
• 无法（希望只是现在）返回捕获数据的引用。

A. 动机

在这里讨论了其中一些问题以及使用 Closure 类型提出的解决方案。

A.1. expected closure, found a different closure

我们都曾在某个时候观察到这个错误信息。这是由于每个闭包都有一个独特的类型。此外，这些是由编译器生成的类型，我们无法直接写出，而是可以写出它们实现的 Fn 特性。

这导致高阶函数或简单地将函数条件性地赋给变量时出现问题。

考虑以下问题 https://github.com/rust-lang/rust/issues/87961。该问题建议澄清错误信息，但也演示了我们无法编写一个非常简单的函数。

fn returns_closure(hmm: bool, y: i32) -> impl Fn(i32) -> i32 {
    if hmm {
        move |x| x + y
    } else {
        move |x| x * y // doesn't compile!
    }
}

let add_three = returns_closure(true, 3);
assert_eq!(42, add_three(39));

let times_two = returns_closure(false, 2);
assert_eq!(42, times_two(21));

上面的代码无法编译，因为本节标题就是这样：）

= note: 预期闭包 [闭包@src\motiv.rs:6:17: 6:25] 找到闭包 [闭包@src\motiv.rs:8:17: 8:25]

因为返回位置上的 impl 不允许泛型返回。它允许我们返回一个无法类型化的具体类型，这个类型由函数的主体而不是调用者决定。

让我们将闭包分解为其组件

• 捕获的数据，比如 Capture。在这里 Capture = i32。
• 非捕获函数；即，一个将 In 转换为 Out 的函数指针 fn，并额外访问 Capture。我们可以将其定义为 fn(&Capture, In) -> Out。这里就是 fn(&i32, i32) -> i32。

对 &Capture 的选择是故意的，因为 Fn 是 Fn、FnOnce 和 FnMut 中的绝对最爱。换句话说，我们希望能够多次调用闭包，并且不希望对其进行修改。如果我们想消费，我们可以简单地通过值捕获；回想一下，数据和 fn 是分开的。

如果我们把闭包看作是这两个组件的乘积；或者简单地看作是这对 (Capture, fn(&Capture, In) -> Out)；很明显，两个 if-else 分支具有相同的类型 (i32, fn(&i32, i32) -> i32)，没有理由将它们视为不同的类型。

这正是 Closure<Capture, In, Out> 结构所做的事情：它将捕获的数据与函数指针分开。然后，这些函数成为相同类型的不同值，因此，以下内容是有效的。

use orx_closure::*;

fn returns_closure(hmm: bool, y: i32) -> Closure<i32, i32, i32> {
    if hmm {
        Capture(y).fun(|y, x| x + y)
    } else {
        Capture(y).fun(|y, x| x * y)
    }
}
let add_three = returns_closure(true, 3);
assert_eq!(42, add_three.call(39));

let times_two = returns_closure(false, 2);
assert_eq!(42, times_two.call(21

甚至下面的也是允许的 :)

fn returns_closure(hmm: bool, y: i32) -> Closure<i32, i32, i32> {
    Capture(y).fun(if hmm { |y, x| x + y } else { |y, x| x * y })
}

错误信息正确地说 即使相同，也没有两个闭包具有相同的类型。但这并不是匿名函数的限制；只要它们不捕获环境并且具有相同的签名，即使它们不同，它们实际上也具有相同的类型。fn 很好。

以下是一个更现实一点的例子，其中我们可以很好地定义 Closure 的类型

use orx_closure::*;
    
fn create_closure(slice: &[i32], exclude_evens: bool) -> Closure<&[i32], i32, Option<i32>> {
    Capture(slice).fun(if exclude_evens {
        |x, lb| x.iter().filter(|&x| x % 2 == 1 && *x > lb).min().cloned()
    } else {
        |x, lb| x.iter().filter(|&x| *x > lb).min().cloned()
    })
}

let numbers: Vec<i32> = vec![1, 2, 3, 4, 5, 6];

let closure = create_closure(&numbers, true);
let fun = closure.as_fn(); // not to call 'call'

assert_eq!(fun(1), Some(3));
assert_eq!(fun(5), None);

为什么不直接用 Box 呢？

确实，额外的间接引用解决了这里提到的大部分问题，但不是所有问题。例如，以下代码可以编译并正常工作。

fn returns_closure(hmm: bool, y: i32) -> Box<dyn Fn(i32) -> i32> {
    if hmm {
        Box::new(move |x| x + y)
    } else {
        Box::new(move |x| x * y)
    }
}
let add_three = returns_closure(true, 3);
assert_eq!(42, add_three(39));

let times_two = returns_closure(false, 2);
assert_eq!(42, times_two(21));

这带来的最大好处是能够忘记捕获的数据。它不在签名中，完全抽象化。我们不知道它的大小，因为我们现在有一个 trait 对象。然而，它也有一些缺点

• 这会增加间接引用。这将导致额外的分配。
• 此外，也许更重要的是，编译器优化的可能性显著降低。
• 这纯粹是个人喜好；代码中出现了诸如 dyn、Box 和 Box::new 这样的单词，这些单词需要在每个分支中重复。

let x = 42;
let return_ref_to_capture = move || &x;
// <- won't compile: ^^ returning this value requires that `'1` must outlive `'2`

let x = 42;
let return_ref_to_capture = Capture(x).fun(|x: &i32, _: ()| x); // <- won't compile

let x = 42;
let return_ref_to_capture = Capture(x).fun_ref(|x: &i32, _: ()| x); // all good :)

let x = 42;
let return_ref_to_capture = Capture(x).fun_option_ref(|x: &i32, _: ()| Some(x)); // all good :)

let x = 42;
let return_ref_to_capture: ClosureResRef<i32, (), i32, String> = // <- String is the error type here.
    Capture(x).fun_result_ref(|x: &i32, _: ()| Ok(x));

let x = 42;

let closure_ref = Capture(&x).fun(|x, _: ()| *x);
assert_eq!(closure_ref.call(()), &42);

let closure_opt_ref = Capture(&x).fun(|x, _: ()| Some(*x));
assert_eq!(closure_opt_ref.call(()), Some(&42));

let closure_res_ref: Closure<_, _, Result<&i32, String>> = Capture(&x).fun(|x, _: ()| Ok(*x));
assert_eq!(closure_res_ref.call(()), Ok(&42));

use orx_closure::*;
use std::collections::HashSet;

type Node = usize; // for brevity
type Edge = (Node, Node); // for brevity

type PrecedenceClosure = ClosureOneOf3<(), Vec<HashSet<Node>>, HashSet<Edge>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant1(closure: Closure<(), Edge, bool>) -> Self {
        Self(closure.into_oneof3_var1())
    }
    fn new_variant2(closure: Closure<Vec<HashSet<Node>>, Edge, bool>) -> Self {
        Self(closure.into_oneof3_var2())
    }
    fn new_variant3(closure: Closure<HashSet<Edge>, Edge, bool>) -> Self {
        Self(closure.into_oneof3_var3())
    }

    fn can_precede(&self, edge: Edge) -> bool {
        self.0.call(edge)
    }
}

let allow_all = Precedence::new_variant1(Capture(()).fun(|_, _| true));
assert_eq!(allow_all.can_precede((0, 1)), true);
assert_eq!(allow_all.can_precede((10, 21)), true);

let disallow_all = Precedence::new_variant1(Capture(()).fun(|_, _| false));
assert_eq!(disallow_all.can_precede((0, 1)), false);
assert_eq!(disallow_all.can_precede((10, 21)), false);

let allowed: Vec<HashSet<Node>> = vec![
    HashSet::from_iter([1, 2, 3].into_iter()),
    HashSet::from_iter([2, 3].into_iter()),
    HashSet::from_iter([3].into_iter()),
    HashSet::from_iter([0].into_iter()),
];
let from_allowed = Precedence::new_variant2(
    Capture(allowed).fun(|allowed, edge| allowed[edge.0].contains(&edge.1)),
);
assert_eq!(from_allowed.can_precede((1, 3)), true);
assert_eq!(from_allowed.can_precede((2, 1)), false);

let taboo = HashSet::from_iter([(0, 3), (1, 2)].into_iter());
let from_taboo =
    Precedence::new_variant3(Capture(taboo).fun(|taboo, edge| !taboo.contains(&edge)));
assert_eq!(from_taboo.can_precede((0, 3)), false);
assert_eq!(from_taboo.can_precede((2, 1)), true);

use orx_closure::*;

type Weight = i32;
type WithClosure<Weight> = Closure<Vec<Vec<Weight>>, (usize, usize), Weight>; // no generics required

struct HoldingFn<F: Fn((usize, usize)) -> Weight> { // requires the generic parameter F
    fun: F,
}

struct HoldingBoxDynFn { // no generics required
    fun: Box<dyn Fn((usize, usize)) -> Weight>,
}

FunAsAField/closure/10000
                        time:   [126.07 ms 126.63 ms 127.23 ms]
FunAsAField/holding_fn/10000
                        time:   [55.149 ms 55.372 ms 55.604 ms]
FunAsAField/holding_box_dyn_fn/10000
                        time:   [127.27 ms 128.24 ms 129.40 ms]