Struct Closure

pub struct Closure<Capture, In, Out> { /* private fields */ }

Closure strictly separating the captured data from the function, and hence, having two components:

• Capture is any captured data,
• fn(&Capture, In) -> Out is the transformation.

It represents the transformation In -> Out.

Note that, unlike trait objects of fn-traits, Closure auto-implements Clone given that captured data is cloneable.

Example

use orx_closure::*;

let name = String::from("morgana");

// nth_char: Closure<String, usize, Option<char>>
let nth_char = Capture(name).fun(|n, i| n.chars().nth(i));

assert_eq!(Some('m'), nth_char.call(0));

// alternatively
let fun = nth_char.as_fn();
assert_eq!(Some('g'), fun(3));

Implementations

impl<Capture, In, Out> Closure<Capture, In, Out>

pub fn call(&self, input: In) -> Out

Calls the closure with the given input.

Example

use orx_closure::Capture;

let base = 2;
let modulo = Capture(base).fun(|b, n| n % b);

assert_eq!(0, modulo.call(42));
assert_eq!(1, modulo.call(7));

pub fn captured_data(&self) -> &Capture

Returns a reference to the captured data.

pub fn into_captured_data(self) -> Capture

Consumes the closure and returns back the captured data.

use orx_closure::Capture;

struct ExpensiveData(Vec<i32>);

let data = ExpensiveData(vec![0, 1, 2]);

let get_number = Capture(data).fun(|data, i| 42 + data.0[i]);

assert_eq!(42, get_number.call(0));
assert_eq!(44, get_number.call(2));

let _data: ExpensiveData = get_number.into_captured_data();

pub fn as_fn(&self) -> impl Fn(In) -> Out + '_

Returns the closure as an impl Fn(In) -> Out struct, allowing the convenience

• to avoid the call method,
• or pass the closure to functions accepting a function generic over the Fn.

Example

use orx_closure::Capture;

let base = 2;
let modulo = Capture(base).fun(|b, n| n % b);

// with call method
assert_eq!(0, modulo.call(42));
assert_eq!(1, modulo.call(7));

// getting it as 'Fn' and directly calling the closure
let module_fn = modulo.as_fn();
assert_eq!(0, module_fn(42));
assert_eq!(1, module_fn(7));

impl<Capture, In, Out> Closure<Capture, In, Out>

pub fn into_oneof2_var1<Var2>(self) -> ClosureOneOf2<Capture, Var2, In, Out>

Transforms Closure<C1, In, Out> into the more general ClosureOneOf2<C1, C2, In, Out> for any C2.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant1(closure: Closure<(), Edge, bool>) -> Self {
        // transforms        : Closure<(), Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var1())
    }
}

pub fn into_oneof2_var2<Var1>(self) -> ClosureOneOf2<Var1, Capture, In, Out>

Transforms Closure<C2, In, Out> into the more general ClosureOneOf2<C1, C2, In, Out> for any C1.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant2(closure: Closure<Vec<HashSet<Node>>, Edge, bool>) -> Self {
        // transforms        : Closure<Vec<HashSet<Node>>, Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var2())
    }
}

impl<Capture, In, Out> Closure<Capture, In, Out>

pub fn into_oneof3_var1<Var2, Var3>( self, ) -> ClosureOneOf3<Capture, Var2, Var3, In, Out>

Transforms Closure<C1, In, Out> into the more general ClosureOneOf3<C1, C2, C3, In, Out> for any C2 and C3.

The example below illustrates the usage of the closure over two possible types of captures; however, ClosureOneOf3 is only a generalization of the below for three different capture types.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant1(closure: Closure<(), Edge, bool>) -> Self {
        // transforms        : Closure<(), Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var1())
    }
}

pub fn into_oneof3_var2<Var1, Var3>( self, ) -> ClosureOneOf3<Var1, Capture, Var3, In, Out>

Transforms Closure<C2, In, Out> into the more general ClosureOneOf3<C1, C2, C3, In, Out> for any C1 and C3.

The example below illustrates the usage of the closure over two possible types of captures; however, ClosureOneOf3 is only a generalization of the below for three different capture types.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant2(closure: Closure<Vec<HashSet<Node>>, Edge, bool>) -> Self {
        // transforms        : Closure<Vec<HashSet<Node>>, Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var2())
    }
}

pub fn into_oneof3_var3<Var1, Var2>( self, ) -> ClosureOneOf3<Var1, Var2, Capture, In, Out>

Transforms Closure<C3, In, Out> into the more general ClosureOneOf3<C1, C2, C3, In, Out> for any C1 and C2.

The example below illustrates the usage of the closure over two possible types of captures; however, ClosureOneOf3 is only a generalization of the below for three different capture types.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant2(closure: Closure<Vec<HashSet<Node>>, Edge, bool>) -> Self {
        // transforms        : Closure<Vec<HashSet<Node>>, Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var2())
    }
}

impl<Capture, In, Out> Closure<Capture, In, Out>

pub fn into_oneof4_var1<Var2, Var3, Var4>( self, ) -> ClosureOneOf4<Capture, Var2, Var3, Var4, In, Out>

Transforms Closure<C1, In, Out> into the more general ClosureOneOf4<C1, C2, C3, C4, In, Out> for any C2, C3 and C4.

The example below illustrates the usage of the closure over two possible types of captures; however, ClosureOneOf3 is only a generalization of the below for three different capture types.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant1(closure: Closure<(), Edge, bool>) -> Self {
        // transforms        : Closure<(), Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var1())
    }
}

pub fn into_oneof4_var2<Var1, Var3, Var4>( self, ) -> ClosureOneOf4<Var1, Capture, Var3, Var4, In, Out>

Transforms Closure<C2, In, Out> into the more general ClosureOneOf4<C1, C2, C3, C4, In, Out> for any C1, C3 and C4.

The example below illustrates the usage of the closure over two possible types of captures; however, ClosureOneOf4 is only a generalization of the below for three different capture types.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant2(closure: Closure<Vec<HashSet<Node>>, Edge, bool>) -> Self {
        // transforms        : Closure<Vec<HashSet<Node>>, Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var2())
    }
}

pub fn into_oneof4_var3<Var1, Var2, Var4>( self, ) -> ClosureOneOf4<Var1, Var2, Capture, Var4, In, Out>

Transforms Closure<C3, In, Out> into the more general ClosureOneOf4<C1, C2, C3, C4, In, Out> for any C1, C2 and C4.

The example below illustrates the usage of the closure over two possible types of captures; however, ClosureOneOf4 is only a generalization of the below for three different capture types.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant2(closure: Closure<Vec<HashSet<Node>>, Edge, bool>) -> Self {
        // transforms        : Closure<Vec<HashSet<Node>>, Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var2())
    }
}

pub fn into_oneof4_var4<Var1, Var2, Var3>( self, ) -> ClosureOneOf4<Var1, Var2, Var3, Capture, In, Out>

Transforms Closure<C4, In, Out> into the more general ClosureOneOf4<C1, C2, C3, C4, In, Out> for any C1, C2 and C3.

The example below illustrates the usage of the closure over two possible types of captures; however, ClosureOneOf4 is only a generalization of the below for three different capture types.

Example

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

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

// captures either () or Vec<HashSet<Node>>
type PrecedenceClosure = ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>;

struct Precedence(PrecedenceClosure);

impl Precedence {
    fn new_variant2(closure: Closure<Vec<HashSet<Node>>, Edge, bool>) -> Self {
        // transforms        : Closure<Vec<HashSet<Node>>, Edge, bool>
        // into more general : ClosureOneOf2<(), Vec<HashSet<Node>>, Edge, bool>
        Self(closure.into_oneof2_var2())
    }
}

Trait Implementations

impl<Capture: Clone, In: Clone, Out: Clone> Clone for Closure<Capture, In, Out>

fn clone(&self) -> Closure<Capture, In, Out>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Capture: Debug, In, Out> Debug for Closure<Capture, In, Out>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Capture, In, Out> Fun<In, Out> for Closure<Capture, In, Out>

fn call(&self, input: In) -> Out

Calls the function with the given input and returns the produced output.