Struct Signature 

pub struct Signature {
    pub type_signature: TypeSignature,
    pub volatility: Volatility,
    pub parameter_names: Option<Vec<String>>,
}

Provides information necessary for calling a function.

• TypeSignature defines the argument types that a function has implementations for.

• Volatility defines how the output of the function changes with the input.

Fields

type_signature: TypeSignature

The data types that the function accepts. See TypeSignature for more information.

volatility: Volatility

The volatility of the function. See Volatility for more information.

parameter_names: Option<Vec<String>>

Optional parameter names for the function arguments.

If provided, enables named argument notation for function calls (e.g., func(a => 1, b => 2)). The length must match the number of arguments defined by type_signature.

Defaults to None, meaning only positional arguments are supported.

Implementations

impl Signature

pub fn new(type_signature: TypeSignature, volatility: Volatility) -> Self

Creates a new Signature from a given type signature and volatility.

pub fn variadic(common_types: Vec<DataType>, volatility: Volatility) -> Self

An arbitrary number of arguments with the same type, from those listed in common_types.

pub fn user_defined(volatility: Volatility) -> Self

User-defined coercion rules for the function.

pub fn numeric(arg_count: usize, volatility: Volatility) -> Self

A specified number of numeric arguments

pub fn string(arg_count: usize, volatility: Volatility) -> Self

A specified number of string arguments

pub fn variadic_any(volatility: Volatility) -> Self

An arbitrary number of arguments of any type.

pub fn uniform( arg_count: usize, valid_types: Vec<DataType>, volatility: Volatility, ) -> Self

A fixed number of arguments of the same type, from those listed in valid_types.

pub fn exact(exact_types: Vec<DataType>, volatility: Volatility) -> Self

Exactly matches the types in exact_types, in order.

pub fn coercible(target_types: Vec<Coercion>, volatility: Volatility) -> Self

Target coerce types in order

pub fn comparable(arg_count: usize, volatility: Volatility) -> Self

Used for function that expects comparable data types, it will try to coerced all the types into single final one.

pub fn nullary(volatility: Volatility) -> Self

pub fn any(arg_count: usize, volatility: Volatility) -> Self

A specified number of arguments of any type

pub fn one_of( type_signatures: Vec<TypeSignature>, volatility: Volatility, ) -> Self

Any one of a list of TypeSignatures.

pub fn array_and_element(volatility: Volatility) -> Self

Specialized Signature for ArrayAppend and similar functions.

pub fn element_and_array(volatility: Volatility) -> Self

Specialized Signature for ArrayPrepend and similar functions.

pub fn arrays( n: usize, coercion: Option<ListCoercion>, volatility: Volatility, ) -> Self

Specialized Signature for functions that take a fixed number of arrays.

pub fn array_and_element_and_optional_index(volatility: Volatility) -> Self

Specialized Signature for Array functions with an optional index.

pub fn array_and_index(volatility: Volatility) -> Self

Specialized Signature for ArrayElement and similar functions.

pub fn array(volatility: Volatility) -> Self

Specialized Signature for ArrayEmpty and similar functions.

pub fn with_parameter_names(self, names: Vec<impl Into<String>>) -> Result<Self>

Add parameter names to this signature, enabling named argument notation.

Example

let sig =
    Signature::exact(vec![DataType::Int32, DataType::Utf8], Volatility::Immutable)
        .with_parameter_names(vec!["count".to_string(), "name".to_string()]);

Errors

Returns an error if the number of parameter names doesn’t match the signature’s arity. For signatures with variable arity (e.g., Variadic, VariadicAny), parameter names cannot be specified.

Trait Implementations

impl Clone for Signature

fn clone(&self) -> Signature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Signature

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

Formats the value using the given formatter.

impl Hash for Signature

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 Signature

fn eq(&self, other: &Signature) -> 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 PartialOrd for Signature

fn partial_cmp(&self, other: &Signature) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Signature

impl StructuralPartialEq for Signature