Trait sandkiste::Callback

pub trait Callback<'a>: Machine<'a> {
    // Required method
    fn callback<'b, 'c, F, R>(
        &'b self,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Vec<Self::Datum<'b, 'static>>) -> Result<R, Box<dyn Error>>;

    // Provided methods
    fn callback_expect_args<'b, 'c, F, R>(
        &'b self,
        argc: usize,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Vec<Self::Datum<'b, 'static>>) -> Result<R, Box<dyn Error>> { ... }
    fn callback_expect_min_args<'b, 'c, F, R>(
        &'b self,
        argc: usize,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Vec<Self::Datum<'b, 'static>>) -> Result<R, Box<dyn Error>> { ... }
    fn callback_1arg<'b, 'c, F, R>(
        &'b self,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>> { ... }
    fn callback_2arg<'b, 'c, F, R>(
        &'b self,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>> { ... }
    fn callback_3arg<'b, 'c, F, R>(
        &'b self,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>> { ... }
    fn callback_4arg<'b, 'c, F, R>(
        &'b self,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>> { ... }
    fn callback_5arg<'b, 'c, F, R>(
        &'b self,
        func: F
    ) -> Result<Self::Datum<'b, 'static>, MachineError>
       where R: IntoIterator<Item = Self::Datum<'b, 'c>>,
             <R as IntoIterator>::IntoIter: ExactSizeIterator,
             F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>> { ... }
}

Ability of Machines to call provided callbacks

Example

use std::rc::Rc;
use std::cell::RefCell;
use sandkiste::prelude::*;

fn collect_output<'a, 'b, M, C>(
    machine: &'b M,
    setup: C,
    run: C,
) -> Result<String, MachineError>
where
    M: Machine<'a> + Compile<'a, C> + Callback<'a>,
    for<'c> <M as Machine<'a>>::Datum<'b, 'c>: MaybeString<'c>,
{
    let output_cell = RefCell::new(String::new());
    let output_rc = Rc::new(output_cell);
    let output_weak = Rc::downgrade(&output_rc);

    let my_print = machine
        .callback_1arg(move |s| {
            output_weak
                .upgrade()
                .ok_or("closure expired")?
                .borrow_mut()
                .push_str(s.try_as_str()?);
            Ok([])
        })?;

    machine.compile(None, setup)?.call([my_print])?;
    machine.compile(None, run)?.call([])?;

    Ok(Rc::try_unwrap(output_rc).unwrap().into_inner())
}

Required Methods

fn callback<'b, 'c, F, R>( &'b self, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Vec<Self::Datum<'b, 'static>>) -> Result<R, Box<dyn Error>>,

Create a Machine::Datum representing a callback (which invokes the func closure)

Provided Methods

fn callback_expect_args<'b, 'c, F, R>( &'b self, argc: usize, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Vec<Self::Datum<'b, 'static>>) -> Result<R, Box<dyn Error>>,

Same as Callback::callback but expects a fixed number of arguments

fn callback_expect_min_args<'b, 'c, F, R>( &'b self, argc: usize, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Vec<Self::Datum<'b, 'static>>) -> Result<R, Box<dyn Error>>,

Same as Callback::callback but expects a minimum number of arguments

fn callback_1arg<'b, 'c, F, R>( &'b self, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>>,

Same as Callback::callback but expects exactly one argument

fn callback_2arg<'b, 'c, F, R>( &'b self, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>>,

Same as Callback::callback but expects exactly two arguments

fn callback_3arg<'b, 'c, F, R>( &'b self, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>>,

Same as Callback::callback but expects exactly three arguments

fn callback_4arg<'b, 'c, F, R>( &'b self, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>>,

Same as Callback::callback but expects exactly four arguments

fn callback_5arg<'b, 'c, F, R>( &'b self, func: F ) -> Result<Self::Datum<'b, 'static>, MachineError>where R: IntoIterator<Item = Self::Datum<'b, 'c>>, <R as IntoIterator>::IntoIter: ExactSizeIterator, F: 'a + Fn(Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>, Self::Datum<'b, 'static>) -> Result<R, Box<dyn Error>>,

Same as Callback::callback but expects exactly five arguments

Implementors