Trait SplitStrategy 

pub trait SplitStrategy:
    Send
    + Sync
    + Sized
    + 'static
    + Copy
    + Clone
    + Default
    + Debug
    + PartialEq
    + Eq {
    type CancelToken: Cancellation;

    const SYMBOL_EXTRACTORS: &[SymbolRuleExtractor<Self>] = _;
    const RULE_EXTRACTORS: &[RuleExtractor<Self>] = _;

    // Required methods
    fn strategies<'t, A, B, R>(
        solver: &mut CheckRef<'t, '_, Self>,
        strategy_a: &'static str,
        oper_a: A,
        strategy_b: &'static str,
        oper_b: B,
    ) -> Option<R>
       where A: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send,
             B: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send,
             R: Send + Debug + Clone;
    fn split_i<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>(
        slf: &mut CheckRef<'t, '_, Self>,
        msg: bool,
        rules: SmallVec<&'t Rl, 2>,
        then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync,
    ) -> Result<R, SmallVec<RefCheckLog<'t>, 2>>;

    // Provided methods
    fn split<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>(
        slf: &mut CheckRef<'t, '_, Self>,
        msg: bool,
        rules: SmallVec<&'t Rl, 2>,
        then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync,
    ) -> Option<R> { ... }
    fn strategies_st<'t, A, B, R>(
        solver: &mut CheckRef<'t, '_, Self>,
        strategy_a: &'static str,
        oper_a: A,
        strategy_b: &'static str,
        oper_b: B,
    ) -> Option<R>
       where A: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send,
             B: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send,
             R: Send + Debug + Clone { ... }
    fn split_i_st<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>(
        slf: &mut CheckRef<'t, '_, Self>,
        msg: bool,
        rules: SmallVec<&'t Rl, 2>,
        then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync,
    ) -> Result<R, SmallVec<RefCheckLog<'t>, 2>> { ... }
    fn strategies_mt<'t, A, B, R>(
        solver: &mut CheckRef<'t, '_, Self>,
        strategy_a: &'static str,
        oper_a: A,
        strategy_b: &'static str,
        oper_b: B,
    ) -> Option<R>
       where A: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send,
             B: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send,
             R: Send + Debug + Clone { ... }
    fn split_i_mt<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>(
        slf: &mut CheckRef<'t, '_, Self>,
        msg: bool,
        rules: SmallVec<&'t Rl, 2>,
        then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync,
    ) -> Result<R, SmallVec<RefCheckLog<'t>, 2>> { ... }
}

Provided Associated Constants

const SYMBOL_EXTRACTORS: &[SymbolRuleExtractor<Self>] = _

const RULE_EXTRACTORS: &[RuleExtractor<Self>] = _

Required Associated Types

type CancelToken: Cancellation

Required Methods

fn strategies<'t, A, B, R>( solver: &mut CheckRef<'t, '_, Self>, strategy_a: &'static str, oper_a: A, strategy_b: &'static str, oper_b: B, ) -> Option<R>

where A: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send, B: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send, R: Send + Debug + Clone,

fn split_i<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>( slf: &mut CheckRef<'t, '_, Self>, msg: bool, rules: SmallVec<&'t Rl, 2>, then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync, ) -> Result<R, SmallVec<RefCheckLog<'t>, 2>>

Errors

Provided Methods

fn split<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>( slf: &mut CheckRef<'t, '_, Self>, msg: bool, rules: SmallVec<&'t Rl, 2>, then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync, ) -> Option<R>

fn strategies_st<'t, A, B, R>( solver: &mut CheckRef<'t, '_, Self>, strategy_a: &'static str, oper_a: A, strategy_b: &'static str, oper_b: B, ) -> Option<R>

where A: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send, B: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send, R: Send + Debug + Clone,

fn split_i_st<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>( slf: &mut CheckRef<'t, '_, Self>, msg: bool, rules: SmallVec<&'t Rl, 2>, then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync, ) -> Result<R, SmallVec<RefCheckLog<'t>, 2>>

Errors

fn strategies_mt<'t, A, B, R>( solver: &mut CheckRef<'t, '_, Self>, strategy_a: &'static str, oper_a: A, strategy_b: &'static str, oper_b: B, ) -> Option<R>

where A: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send, B: FnOnce(&mut CheckRef<'t, '_, Self>) -> Option<R> + Send, R: Send + Debug + Clone,

fn split_i_mt<'t, Rl: CheckerRule + ?Sized, R: Send + Debug + Clone + 'static>( slf: &mut CheckRef<'t, '_, Self>, msg: bool, rules: SmallVec<&'t Rl, 2>, then: impl Fn(CheckRef<'t, '_, Self>, &Rl) -> Option<R> + Send + Sync, ) -> Result<R, SmallVec<RefCheckLog<'t>, 2>>

Errors

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl SplitStrategy for RayonSplit

type CancelToken = Atomic<bool>

impl SplitStrategy for RayonStrategiesOnly

type CancelToken = Atomic<bool>

impl SplitStrategy for SingleThreadedSplit

type CancelToken = ()

impl<const DEPTH: usize> SplitStrategy for RayonStrategiesDepth<DEPTH>

type CancelToken = Atomic<bool>