Struct RootedLambdaPool 

pub struct RootedLambdaPool<'src, T: LambdaLanguageOfThought> { /* private fields */ }

A lambda expression with its root defined.

Implementations

impl<'src, T: LambdaLanguageOfThought> RootedLambdaPool<'src, T>

pub fn new_free_variable( index: usize, t: LambdaType, ) -> RootedLambdaPool<'src, T>

Creates an anonymous free variable with [index] of type [t]

pub fn free_variables( &self, ) -> impl Iterator<Item = (&FreeVar<'src>, &LambdaType)>

Gets all free variables that must be bound in order to evaluate this lambda expression

pub fn len(&self) -> usize

Get the length of a lambda tree

impl<'src, T: LambdaLanguageOfThought + Clone> RootedLambdaPool<'src, T>

pub fn cleanup(&mut self)

Clean up dangling references.

pub fn get_type(&self) -> Result<LambdaType, TypeError>

The type of the lambda expression

Errors

Returns a TypeError if the underlying pool is malformed leading to no possible type being extractible.

pub fn merge(self, other: Self) -> Option<Self>

Combine two lambda expressions by applying one to the other. Returns None if that is impossible.

Panics

Will panic if either pool is malformed such that no type can be found.

pub fn apply(self, other: Self) -> Option<Self>

Applies other to self and returns None if the types do not correspond.

Panics

Will panic if either pool is malformed such that no type can be found.

pub fn reduce(&mut self) -> Result<(), ReductionError>

Reduce a lambda expression

Errors

Will throw a ReductionError if there is something makes the reduction improper.

pub fn into_pool(self) -> Result<T::Pool, T::ConversionError>

Convert a lambda expression to its executable version (should only be done if there are only LambdaExpr::LanguageOfThoughtExpr expressions.

Errors

Will throw a [T::ConversionError] if there are any lambda terms left in the pool

pub fn bind_free_variable( &mut self, fvar: FreeVar<'src>, replacement: RootedLambdaPool<'src, T>, ) -> Result<(), LambdaError>

Replace a free variable with a value.

Errors

Will return an error if a FreeVar with the same name but different type already exists

pub fn lambda_abstract_free_variable( &mut self, fvar: FreeVar<'src>, lambda_type: LambdaType, always_abstract: bool, ) -> Result<(), LambdaError>

Replace a free variable by lambda abstracting it. (e.g. $P(x_{free})$ to $\lambda x P(x)$).

Errors

Will throw an error if the free variable has the wrong type.

pub fn apply_new_free_variable( &mut self, fvar: FreeVar<'src>, ) -> Result<LambdaType, LambdaError>

Apply a free variable to a function.

Errors

Will throw an error if there is an issue with the reduction

impl<T: LambdaLanguageOfThought + Clone + Debug> RootedLambdaPool<'_, T>

pub fn lift(&mut self) -> Result<(), TypeError>

Convert an expression phi of type x and convert it to lambda <x,t> P P(phi)

Errors

Will return a type error if the type of the lambda expression is malformed

pub fn stats(&self) -> LambdaSummaryStats

Get LambdaSummaryStats for an expression, e.g. how many context functions, size, etc.

impl<'a> RootedLambdaPool<'a, Expr<'a>>

pub fn conjoin(self, other: Self) -> Result<Self, ConjoiningError>

Takes two lambda expressions, phi and psi of type <x, t> where x is any type and returns phi AND psi.

Errors

Returns a ConjoiningError if self and other are not of the right types such that a

pub fn raised_conjoin(self, other: Self) -> Result<Self, ConjoiningError>

Takes two lambda expressions, phi <x, <y,t>> and psi of type <y, t> where x and y is any type and returns phi AND psi.

This is a generalized kind of Event Identification from Kratzer (1996)

• Kratzer, A. (1996). Severing the External Argument from its Verb. In J. Rooryck & L. Zaring (Eds.), Phrase Structure and the Lexicon (pp. 109–137). Springer Netherlands. https://doi.org/10.1007/978-94-015-8617-7_5

Errors

Returns a ConjoiningError if self and other are not of the right types such that a

pub fn parse(s: &'a str) -> Result<Self, LambdaParseError>

Create a RootedLambdaPool<Expr> from a string.

Errors

Returns a LambdaParseError if the input string is malformed and not a LOT expression.

impl<'src, T: LambdaLanguageOfThought + Clone> RootedLambdaPool<'src, T>

pub fn typeless_sampler( possible_expressions: PossibleExpressions<'src, T>, max_expr: usize, max_types: usize, ) -> TypeAgnosticSampler<'src, T>

Create a sampler which can sample arbitrary types.

Panics

Will panic if max_types == 0 or max_expr == 0

impl<'src> RootedLambdaPool<'src, Expr<'src>>

pub fn resample_from_expr<'a>( &mut self, possible_expressions: &'a PossibleExpressions<'src, Expr<'src>>, helpers: Option<&HashMap<LambdaType, Vec<RootedLambdaPool<'src, Expr<'src>>>>>, rng: &mut impl Rng, ) -> Result<(), LambdaError>

Create a LambdaSampler of a given type.

Errors

Will return a LambdaError if the tree is malformed

Panics

Will panic if the size of the tree is greater than u32::MAX.

pub fn enumerator_filter<'a, F: Fn(&Context) -> bool>( t: &LambdaType, filter: F, possible_expressions: &'a PossibleExpressions<'src, Expr<'src>>, ) -> LambdaEnumerator<'a, 'src, Expr<'src>, F>

Create a LambdaSampler of a given type with a filter

pub fn enumerator<'a>( t: &LambdaType, possible_expressions: &'a PossibleExpressions<'src, Expr<'src>>, ) -> LambdaEnumerator<'a, 'src, Expr<'src>, impl Fn(&Context) -> bool>

Create a LambdaSampler of a given type.

pub fn sampler( t: &LambdaType, possible_expressions: &PossibleExpressions<'src, Expr<'src>>, max_expr: usize, ) -> LambdaSampler<'src, Expr<'src>>

Creates a reusable random sampler by enumerating over the first max_expr expressions

pub fn random_expr( t: &LambdaType, possible_expressions: &PossibleExpressions<'src, Expr<'src>>, rng: &mut impl Rng, ) -> RootedLambdaPool<'src, Expr<'src>>

Randomly generate a RootedLambdaPool of type t.

Panics

Will panic if no such type can be generated.

pub fn random_expr_no_constant( t: &LambdaType, possible_expressions: &PossibleExpressions<'src, Expr<'src>>, rng: &mut impl Rng, ) -> Option<RootedLambdaPool<'src, Expr<'src>>>

Randomly generate a RootedLambdaPool of type t without constant functions.

impl<'src> RootedLambdaPool<'src, Expr<'src>>

pub fn prune_quantifiers(&mut self)

Remove quantifiers which do not use their variable in their body.

pub fn swap_expr( &mut self, possible_expressions: &PossibleExpressions<'src, Expr<'src>>, rng: &mut impl Rng, ) -> Result<(), TypeError>

Replace a random expression with something else of the same type.

Errors

Will return a TypeError if there is no compatible type to replace

Panics

Will panic if the size of the tree is greater than u32::MAX.

pub fn swap_subtree(&mut self, rng: &mut impl Rng) -> Result<(), TypeError>

Replace a random expression with something else of the same type from within the same expression.

Errors

Will return TypeError if a compatible subtree can’t be found.

Panics

Will panic if the size of the tree is greater than u32::MAX.

impl<'src> RootedLambdaPool<'src, Expr<'src>>

pub fn for_document(&self) -> MathModeExpression<'_>

Get a [MathModeExpression] to be serialized for documents.

Trait Implementations

impl<'src, T: Clone + LambdaLanguageOfThought> Clone for RootedLambdaPool<'src, T>

fn clone(&self) -> RootedLambdaPool<'src, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'src, T: Debug + LambdaLanguageOfThought> Debug for RootedLambdaPool<'src, T>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for RootedLambdaPool<'a, Expr<'a>>

where 'de: 'a,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Display for RootedLambdaPool<'a, Expr<'a>>

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

Formats the value using the given formatter.

impl<'src, T: LambdaLanguageOfThought + Clone> Distribution<RootedLambdaPool<'src, T>> for LambdaSampler<'src, T>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> RootedLambdaPool<'src, T>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<'a> From<LanguageExpression<'a>> for RootedLambdaPool<'a, Expr<'a>>

fn from(value: LanguageExpression<'a>) -> Self

Converts to this type from the input type.

impl<T: LambdaLanguageOfThought + HashLambda> Hash for RootedLambdaPool<'_, T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: LambdaLanguageOfThought + PartialEq + Eq> Ord for RootedLambdaPool<'_, T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + LambdaLanguageOfThought> PartialEq for RootedLambdaPool<'_, T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: LambdaLanguageOfThought + PartialEq + Eq> PartialOrd for RootedLambdaPool<'_, T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'src> Serialize for RootedLambdaPool<'src, Expr<'src>>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq + LambdaLanguageOfThought> Eq for RootedLambdaPool<'_, T>