Enum arithmetic_typing::defs::Prelude

#[non_exhaustive]
pub enum Prelude {
    False,
    True,
    If,
    While,
    Defer,
    Map,
    Filter,
    Fold,
    Push,
    Merge,
    All,
    Any,
}

Map containing type definitions for all variables from Prelude in the eval crate.

Contents

• true and false Boolean constants
• if, while, map, filter, fold, push and merge functions

The merge function has somewhat imprecise typing; its return value is a dynamically-sized slice.

The array function is available separately via Self::array().

Examples

Function counting number of zeros in a slice:

use arithmetic_parser::grammars::{F32Grammar, Parse};
use arithmetic_typing::{defs::Prelude, Annotated, TypeEnvironment, Type};

let code = "|xs| xs.fold(0, |acc, x| if(x == 0, acc + 1, acc))";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;

let mut env: TypeEnvironment = Prelude::iter().collect();
let count_zeros_fn = env.process_statements(&ast)?;
assert_eq!(count_zeros_fn.to_string(), "([Num; N]) -> Num");

Limitations of merge:

let code = "
    len = |xs| xs.fold(0, |acc, _| acc + 1);
    slice = (1, 2).merge((3, 4));
    slice.len(); // methods working on slices are applicable
    (_, _, _, z) = slice; // but destructuring is not
";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;

let mut env: TypeEnvironment = Prelude::iter().collect();
let errors = env.process_statements(&ast).unwrap_err();
assert_eq!(errors.len(), 1);
let err = errors.iter().next().unwrap();
assert_eq!(err.main_location().span(code), "(_, _, _, z)");

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

False

false type (Boolean).

True

true type (Boolean).

If

Type of the if function.

While

Type of the while function.

Defer

Type of the defer function.

Map

Type of the map function.

Filter

Type of the filter function.

Fold

Type of the fold function.

Push

Type of the push function.

Merge

Type of the merge function.

All

Type of the all function.

Any

Type of the any function.

Implementations

impl Prelude

pub fn array<T: PrimitiveType>(index_type: T) -> Function<T>

Returns the type of the array generation function from the eval crate.

The array function is not included into Self::iter() because in the general case we don’t know the type of indexes.

pub fn iter<Prim: WithBoolean>() -> impl Iterator<Item = (&'static str, Type<Prim>)>

Returns an iterator over all type definitions in the Prelude.

Trait Implementations

impl Clone for Prelude

fn clone(&self) -> Prelude

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Prelude

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

Formats the value using the given formatter.

impl<Prim: WithBoolean> From<Prelude> for Type<Prim>

fn from(value: Prelude) -> Self

Converts to this type from the input type.

impl Hash for Prelude

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 PartialEq for Prelude

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Prelude

impl Eq for Prelude

impl StructuralPartialEq for Prelude