Enum Function 

pub enum Function {
    Remote(RemoteFunction),
    Inline(InlineFunction),
}

A Function definition, either remote or inline.

Functions are composable scoring pipelines that transform structured input into scores. Each task has an output expression that transforms its raw result into a TaskOutputOwned. The function’s final output is the weighted average of all task outputs using profile weights.

Use compile_tasks to preview how task expressions resolve for given inputs.

Variants

Remote(RemoteFunction)

A remote function with metadata (description, schema, etc.).

Inline(InlineFunction)

An inline function definition without metadata.

Implementations

impl Function

pub fn validate_input(&self, input: &InputValue) -> Option<bool>

Validates the input against the function’s input schema.

For remote functions, checks whether the provided input conforms to the function’s JSON Schema definition. For inline functions, returns None since they lack schema definitions.

Returns

• Some(true) if the input is valid against the schema
• Some(false) if the input is invalid
• None for inline functions (no schema to validate against)

pub fn compile_tasks( self, input: &InputValue, ) -> Result<Vec<Option<CompiledTask>>, ExpressionError>

Compiles task expressions to show the final tasks for a given input.

Evaluates all expressions (JMESPath or Starlark) in the function’s tasks using the provided input data. Tasks with skip expressions that evaluate to true return None. Tasks with map fields produce multiple task instances.

Returns

A vector where each element corresponds to a task definition:

• None if the task was skipped
• Some(CompiledTask::One(...)) for non-mapped tasks
• Some(CompiledTask::Many(...)) for mapped tasks

pub fn compile_output_length( self, input: &InputValue, ) -> Result<Option<u64>, ExpressionError>

Computes the expected output length for a vector function.

Evaluates the output_length expression to determine how many elements the output vector should contain. This is only applicable to remote vector functions which have an output_length field.

Arguments

• input - The function input used to compute the output length

Returns

• Ok(Some(u64)) - The expected output length for remote vector functions
• Ok(None) - For scalar functions or inline functions
• Err(ExpressionError) - If the expression fails to compile

pub fn compile_input_split( self, input: &InputValue, ) -> Result<Option<Vec<InputValue>>, ExpressionError>

Compiles the input_split expression to split input into multiple sub-inputs.

Used by strategies like Swiss System that need to partition input into smaller pools. The expression transforms the original input into an array of inputs, where each element can be processed independently.

Arguments

• input - The original function input to split

Returns

• Ok(Some(Vec<Input>)) - The split inputs for vector functions with input_split defined
• Ok(None) - For scalar functions or functions without input_split
• Err(ExpressionError) - If the expression fails to compile

pub fn compile_input_merge( self, input: &InputValue, ) -> Result<Option<InputValue>, ExpressionError>

Compiles the input_merge expression to merge multiple sub-inputs back into one.

Used by strategies like Swiss System to recombine a subset of split inputs into a single input for pool execution. The expression transforms an array of inputs (a subset from input_split) into a single merged input.

Arguments

• input - An array of inputs to merge (typically a subset from compile_input_split)

Returns

• Ok(Some(Input)) - The merged input for vector functions with input_merge defined
• Ok(None) - For scalar functions or functions without input_merge
• Err(ExpressionError) - If the expression fails to compile

pub fn description(&self) -> Option<&str>

Returns the function’s description, if available.

pub fn input_schema(&self) -> Option<&InputSchema>

Returns the function’s input schema, if available.

pub fn tasks(&self) -> &[TaskExpression]

Returns the function’s tasks.

pub fn output_length(&self) -> Option<&Expression>

Returns the function’s expected output length expression, if defined.

pub fn input_split(&self) -> Option<&Expression>

Returns the function’s input_split expression, if defined.

pub fn input_merge(&self) -> Option<&Expression>

Returns the function’s input_merge expression, if defined.

Trait Implementations

impl Clone for Function

fn clone(&self) -> Function

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Function

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Function

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Function

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Function

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Function