Struct arithmetic_typing::arith::NumArithmetic

pub struct NumArithmetic { /* private fields */ }

Arithmetic on Numbers.

Unary ops

• Unary minus is follows the equation -T == T, where T is any linear type.
• Unary negation is only defined for Bools.

Binary ops

Binary ops fall into 3 cases: Num op T == T, T op Num == T, or T op T == T, where T is any linear type (that is, Num or tuple of linear types). T op T is assumed by default, only falling into two other cases if one of operands is known to be a number and the other is not a number.

Comparisons

Order comparisons (>, <, >=, <=) can be switched on or off. Use Self::with_comparisons() constructor to switch them on. If switched on, both arguments of the order comparison must be numbers.

Implementations

impl NumArithmetic

pub const fn without_comparisons() -> Self

Creates an instance of arithmetic that does not support order comparisons.

pub const fn with_comparisons() -> Self

Creates an instance of arithmetic that supports order comparisons.

pub fn unify_binary_op<Prim: PrimitiveType>( substitutions: &mut Substitutions<Prim>, context: &BinaryOpContext<Prim>, errors: OpErrors<'_, Prim>, settings: OpConstraintSettings<'_, Prim>, ) -> Type<Prim>

Applies binary ops logic to unify the given LHS and RHS types. Returns the result type of the binary operation.

This logic can be reused by other TypeArithmetic implementations.

Arguments

• settings are applied to arguments of arithmetic ops.

pub fn process_unary_op<Prim: WithBoolean>( substitutions: &mut Substitutions<Prim>, context: &UnaryOpContext<Prim>, errors: OpErrors<'_, Prim>, constraints: &impl Constraint<Prim>, ) -> Type<Prim>

Processes a unary operation according to the numeric arithmetic rules. Returns the result type of the unary operation.

This logic can be reused by other TypeArithmetic implementations.

pub fn process_binary_op<Prim: WithBoolean>( substitutions: &mut Substitutions<Prim>, context: &BinaryOpContext<Prim>, errors: OpErrors<'_, Prim>, comparable_type: Option<Prim>, settings: OpConstraintSettings<'_, Prim>, ) -> Type<Prim>

Processes a binary operation according to the numeric arithmetic rules. Returns the result type of the unary operation.

This logic can be reused by other TypeArithmetic implementations.

Arguments

• If comparable_type is set to Some(_), it will be used to unify arguments of order comparisons. If comparable_type is None, order comparisons are not supported.
• constraints are applied to arguments of arithmetic ops.

Trait Implementations

impl Clone for NumArithmetic

fn clone(&self) -> NumArithmetic

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NumArithmetic

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

Formats the value using the given formatter.

impl<Val> MapPrimitiveType<Val> for NumArithmetic

where Val: Clone + NumOps + PartialEq,

type Prim = Num

Types of literals output by this mapper.

fn type_of_literal(&self, _: &Val) -> Self::Prim

Gets the type of the provided literal value.

impl TypeArithmetic<Num> for NumArithmetic

fn process_unary_op( &self, substitutions: &mut Substitutions<Num>, context: &UnaryOpContext<Num>, errors: OpErrors<'_, Num>, ) -> Type<Num>

Handles a unary operation.

fn process_binary_op( &self, substitutions: &mut Substitutions<Num>, context: &BinaryOpContext<Num>, errors: OpErrors<'_, Num>, ) -> Type<Num>

Handles a binary operation.