Struct Regular

pub(super) struct Regular {
    pub arity: usize,
    pub constructors: ConstructorSet,
    pub scalars: ScalarSet,
    pub conclude: ConclusionRule,
}

Overload sets represented as sets of scalars and constructors.

This type represents an OverloadSet using a bitset of scalar types and a bitset of type constructors that might be applied to those scalars. The overload set contains a rule for every possible combination of scalars and constructors, essentially the cartesian product of the two sets.

For example, if the arity is 2, set of scalars is { AbstractFloat, f32 }, and the set of constructors is { vec2, vec3 }, then that represents the set of overloads:

• (vec2<AbstractFloat>, vec2<AbstractFloat>) -> vec2<AbstractFloat>
• (vec2<f32>, vec2<f32>) -> vec2<f32>
• (vec3<AbstractFloat>, vec3<AbstractFloat>) -> vec3<AbstractFloat>
• (vec3<f32>, vec3<f32>) -> vec3<f32>

The conclude value says how to determine the return type from the argument type.

Restrictions:

• All overloads must take the same number of arguments.

• For any given overload, all its arguments must have the same type.

Fields

arity: usize

The number of arguments in the rules.

constructors: ConstructorSet

The set of type constructors to apply.

scalars: ScalarSet

The set of scalars to apply them to.

conclude: ConclusionRule

How to determine a member rule’s return type given the type of its arguments.

Implementations

impl Regular

pub(super) const EMPTY: Regular

fn members(&self) -> impl Iterator<Item = (ConstructorSize, Scalar)>

Return an iterator over all the argument types allowed by self.

Return an iterator that produces, for each overload in self, the constructor and scalar of its argument types and return type.

A Regular value can only represent overload sets where, in each overload, all the arguments have the same type, and the return type is always going to be a determined by the argument types, so giving the constructor and scalar is sufficient to characterize the entire rule.

fn rules(&self) -> impl Iterator<Item = Rule>

Trait Implementations

impl Clone for Regular

fn clone(&self) -> Regular

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ForDebugWithTypes for &Regular

fn for_debug( self, types: &UniqueArena<Type>, ) -> DiagnosticDebug<(Self, &UniqueArena<Type>)>

Format this type using core::fmt::Debug.

impl From<Regular> for AnyOverloadSet

fn from(concrete: Regular) -> Self

Converts to this type from the input type.

impl OverloadSet for Regular

fn is_empty(&self) -> bool

Return true if self is the empty set of overloads.

fn min_arguments(&self) -> usize

Return the smallest number of arguments in any type rule in the set.

fn max_arguments(&self) -> usize

Return the largest number of arguments in any type rule in the set.

fn arg(&self, i: usize, ty: &TypeInner, types: &UniqueArena<Type>) -> Self

Find the overloads that could accept a given argument.

fn concrete_only(self, _types: &UniqueArena<Type>) -> Self

Limit self to overloads whose arguments are all concrete types.

fn most_preferred(&self) -> Rule

Return the most preferred candidate.

fn overload_list(&self, _gctx: &GlobalCtx<'_>) -> Vec<Rule>

Return a type rule for each of the overloads in self.

fn allowed_args(&self, i: usize, _gctx: &GlobalCtx<'_>) -> Vec<TypeResolution>

Return a list of the types allowed for argument i.

fn for_debug(&self, types: &UniqueArena<Type>) -> impl Debug

Return an object that can be formatted with core::fmt::Debug.