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

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

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

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

Reduce a lambda expression

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.

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

Replace a free variable with a value.

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)$).

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

Apply a free variable to a function.

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)

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.

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

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

Create a RootedLambdaPool<Expr> from a string.

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.

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.

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.

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.

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.

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: 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<'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 + Eq + LambdaLanguageOfThought> Eq for RootedLambdaPool<'_, T>