Struct AlgorithmSignature 

pub struct AlgorithmSignature {
    pub output_fields: Vec<Field>,
    pub docs: String,
    pub args: Vec<NamedArgType>,
    pub slices: Vec<SliceReq>,
    pub df_composable: bool,
}

Static signature of an algorithm.

args and slices are additive, defaulted fields (construct with ..Default::default()): existing providers that leave them empty keep the legacy untyped config_json contract unchanged. A provider that declares args opts into host-side arity/type validation before it runs (proposal §4.6 / decision D7); a provider that declares slices opts into load-time capability-slice version negotiation (proposal §4.3 / decision D6).

Fields

output_fields: Vec<Field>

Output column schema.

docs: String

Markdown docs.

args: Vec<NamedArgType>

Declared positional arguments, in call order.

Empty (the default) preserves the legacy behavior: arguments arrive as a raw positional config_json array the provider parses itself. When non-empty, the host validates arity and coerces each positional argument against the declared NamedArgType before the provider runs, filling omitted trailing arguments from their declared defaults.

slices: Vec<SliceReq>

Required capability slices, checked at load time.

Empty (the default) means the algorithm targets only the always-present graph-compute@1 surface. A declared SliceReq whose version the host does not provide fails the load with a clear error (0x86A) rather than a mysterious runtime “unknown kernel op” trap.

df_composable: bool

Whether a CALL of this algorithm may be planned as a first-class DataFusion ExecutionPlan node (the vectorized path), rather than only through the row-based interpreter (proposal §6, DF-3).

false (the default) preserves the row path. A provider sets this true to declare it composes correctly as a leaf/source plan node — its run returns a well-formed RecordBatch stream matching output_fields, and it consumes MATCH-bound arguments via outer_values rather than a child plan. This replaces the previous name-prefix allowlist (uni.algo.*): eligibility is now registration-driven, so a third-party myco.algo.* provider that declares df_composable is a first-class plan node like the first-party ones, and a uni.algo.-named provider that does not declare it no longer gets the DF path by prefix alone.

Implementations

impl AlgorithmSignature

pub fn check_slices(&self, host_slices: &[(&str, u16)]) -> Result<(), FnError>

Validates the declared capability slices against host_slices.

Each requirement must be met by a host slice of the same name whose version is at least the requested one. Pass HOST_CAPABILITY_SLICES for the production surface.

Errors

Returns 0x86A (SliceVersionMismatch) naming the first requirement the host cannot satisfy (proposal §4.3 / §12, decision D6).

pub fn coerce_config_json(&self, config_json: &str) -> Result<String, FnError>

Validates and normalizes a positional config_json array against args.

When args is empty this is a no-op returning config_json unchanged, so providers on the legacy untyped contract are unaffected. Otherwise it parses the positional JSON array and, per declared argument: rejects a present value whose JSON kind is incompatible with the declared ArgType, errors on a missing argument that has no default, and appends the declared default for an omitted trailing argument. Extra positional arguments beyond the declared arity are rejected. The returned JSON array is what the provider then parses, so it observes defaults already filled in.

Errors

Returns 0x86E (argument arity/type violation) with a message naming the offending argument (proposal §4.6, decision D7).

Trait Implementations

impl Clone for AlgorithmSignature

fn clone(&self) -> AlgorithmSignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlgorithmSignature

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

Formats the value using the given formatter.

impl Default for AlgorithmSignature

fn default() -> AlgorithmSignature

Returns the “default value” for a type.