Struct Call 

pub struct Call {
    pub span: SourceSpan,
    pub callee: ResolvableIdentifier,
    pub args: Vec<Expr>,
    pub ty: Option<Type>,
}

Represents a function call (either a pure function or an evaluator).

Calls are permitted in a scalar expression context, but arguments to the callee may be non-scalar expressions - it is expected that the callee produces a scalar in such contexts.

Calls to pure functions return scalar or non-scalar values, and so they may be used any place other scalar expressions are supported.

Calls to evaluators are restricted, and have different semantics, though they appear much the same in the language syntax. In particular, evaluators are effectivley callable constraints, and may only appear as the sole expression of a constraint, e.g. enf foo([a, b]).

Because evaluators behave like constraints, they produce no value, so the “type” of a call expression which invokes an evaluator is void. For this reason, calls to evaluators always have a type of None. Pure functions on the other hand must always produce a value, so such calls will always have a valid type. The only time when calls to pure functions will have a None type is prior to name resolution in the semantic analysis pass.

Fields

span: SourceSpan

callee: ResolvableIdentifier

args: Vec<Expr>

ty: Option<Type>

Used to store the type produced by a call to a pure function

The reason this field is an Option is two-fold:

• Calls to evaluators produce no value, and thus have no type
• When parsed, the callee has not yet been resolved, so we don’t know the type of the function being called. During semantic analysis, the callee is resolved and this field is set to the result type of that function.

Implementations

impl Call

pub fn new(span: SourceSpan, callee: Identifier, args: Vec<Expr>) -> Self

pub fn is_builtin(&self) -> bool

Returns true if the callee is a builtin function, e.g. sum

pub fn sum(span: SourceSpan, args: Vec<Expr>) -> Self

Constructs a function call for the sum reducer/fold

pub fn prod(span: SourceSpan, args: Vec<Expr>) -> Self

Constructs a function call for the prod reducer/fold

Trait Implementations

impl Clone for Call

fn clone(&self) -> Call

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Call

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

Formats the value using the given formatter.

impl Display for Call

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

Formats the value using the given formatter.

impl From<Call> for Expr

fn from(expr: Call) -> Self

Converts to this type from the input type.

impl PartialEq for Call

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 Spanned for Call

fn span(&self) -> SourceSpan

impl Eq for Call