Struct GenericFunction 

pub struct GenericFunction { /* private fields */ }

A named generic function: a set of DispatchMethods sharing one name.

This is the dispatch organ’s central object. Methods are added with add_method; a call selects the single most specific applicable primary method (plus around/before/after methods) by matching arguments through the kernel Shape protocol. The kernel defines the callable/operation contracts; this type supplies the concrete dispatch.

Examples

use std::sync::Arc;
use sim_kernel::{Cx, DefaultFactory, ExprKind, NoopEvalPolicy, Shape, Symbol};
use sim_lib_dispatch::{DispatchMethod, GenericFunction, MethodRole};
use sim_shape::{AnyShape, ExprKindShape};

let mut cx = Cx::new(Arc::new(NoopEvalPolicy), Arc::new(DefaultFactory));
let mut generic = GenericFunction::new(Symbol::qualified("demo", "describe"));

// A broad fallback and a more specific string method.
generic.add_method(DispatchMethod::new(
    Symbol::qualified("method", "any"),
    MethodRole::Primary,
    vec![Arc::new(AnyShape) as Arc<dyn Shape>],
    Arc::new(|cx: &mut Cx, _| cx.factory().string("any".to_owned())),
)).unwrap();
generic.add_method(DispatchMethod::new(
    Symbol::qualified("method", "string"),
    MethodRole::Primary,
    vec![Arc::new(ExprKindShape::new(ExprKind::String)) as Arc<dyn Shape>],
    Arc::new(|cx: &mut Cx, _| cx.factory().string("string".to_owned())),
)).unwrap();

let args = [cx.factory().string("hi".to_owned()).unwrap()];
// The string method is more specific, so it is selected.
let selected = generic.select_primary(&mut cx, &args).unwrap();
assert_eq!(selected.method(), &Symbol::qualified("method", "string"));

Implementations

impl GenericFunction

pub fn new(name: Symbol) -> Self

Creates an empty generic function with the given name.

pub fn name(&self) -> &Symbol

Returns the generic function’s name.

pub fn methods(&self) -> &[DispatchMethod]

Returns the methods added to this generic function, in insertion order.

pub fn operation_hints(&self) -> Vec<HintMetadata>

Returns agent-consumable operation hints from the generic and methods.

pub fn add_method(&mut self, method: DispatchMethod) -> Result<()>

Adds a method, erroring if one with the same id, role, and arity exists.

pub fn select_primary( &self, cx: &mut Cx, args: &[Value], ) -> Result<MethodSpecificity>

Returns the specificity of the most specific applicable primary method.

Errors if no primary method applies, or if the two most specific tie (an ambiguous primary).

pub fn dispatch_order(&self, cx: &mut Cx, args: &[Value]) -> Result<Vec<Symbol>>

Returns the method ids in the order call runs them.

The plan is around (most specific first), before (most specific first), the selected primary, then after (least specific first).

pub fn inspect_specificity( &self, cx: &mut Cx, args: &[Value], ) -> Result<Vec<MethodSpecificity>>

Returns every applicable method’s specificity, ordered for display.

Sorts by combination role, then most specific first, then method id; backs the dispatch inspect operation.

pub fn call(&self, cx: &mut Cx, args: &[Value]) -> Result<Value>

Dispatches the call: runs the combination and returns the primary result.

Executes around, before, the selected primary, and after methods in order; errors if no applicable primary method exists.

pub fn call_for_profile( &self, cx: &mut Cx, _profile: &Symbol, args: &[Value], ) -> Result<Value>

Dispatches the call for a named language profile.

One generic function serves every profile: dispatch is profile-neutral, so this delegates to call. The profile argument lets profile-specific surfaces share a single generic.

Trait Implementations

impl Callable for GenericFunction

fn call(&self, cx: &mut Cx, args: Args) -> Result<Value>

Invoke the callable with already-evaluated, checked Args.

fn browse_args_shape(&self, _cx: &mut Cx) -> Result<Option<Value>, Error>

Optional shape describing the accepted argument list, for browsing.

fn browse_result_shape(&self, _cx: &mut Cx) -> Result<Option<Value>, Error>

Optional shape describing the call result, for browsing.

fn call_exprs(&self, cx: &mut Cx, args: RawArgs) -> Result<Value, Error>

Invoke the callable on raw, unevaluated argument expressions.

impl Object for GenericFunction

fn display(&self, _cx: &mut Cx) -> Result<String>

Render the object as a human-readable display string.

fn as_any(&self) -> &dyn Any

Expose the object for Rust downcasting.

fn header(&self) -> &ObjectHeader

Identity and trust header for the object; defaults to the shared anonymous header.

fn op(&self, _key: &OpKey) -> Option<&dyn Op>

Resolve the operation registered under key, if any.

fn claims( &self, _cx: &mut Cx, _pattern: &ClaimPattern, _sink: &mut dyn ClaimSink, ) -> Result<(), Error>

Emit the object’s claims matching pattern into sink.

fn snapshot(&self, _cx: &mut Cx) -> Result<Option<Datum>, Error>

Optional content-addressable snapshot of the object’s state.

impl ObjectCompat for GenericFunction

fn class(&self, cx: &mut Cx) -> Result<ClassRef>

Class object this value belongs to; defaults to nil.

fn as_callable(&self) -> Option<&dyn Callable>

Callable view, if the object can be invoked.

fn as_class(&self) -> Option<&dyn Class>

Class view, if the object is a class.

fn as_shape(&self) -> Option<&dyn Shape>

Shape view, if the object is a shape.

fn as_object_encoder(&self) -> Option<&dyn ObjectEncode>

Object-encoder view, if the object encodes other objects.

fn as_read_constructor(&self) -> Option<&dyn ReadConstructor>

Read-constructor view, if the object decodes data forms.

fn as_number_domain(&self) -> Option<&(dyn NumberDomain + 'static)>

Number-domain view, if the object is a number domain.

fn as_number_value(&self) -> Option<&dyn NumberValue>

Number-value view, if the object is a domain number.

fn as_eval_fabric(&self) -> Option<&dyn EvalFabric>

Eval-fabric view, if the object is a distributed eval surface.

fn as_stream(&self) -> Option<&dyn Stream>

Stream view, if the object is a stream.

fn as_sequence(&self) -> Option<&dyn Sequence>

Sequence view, if the object is a sequence.

fn as_thunk(&self) -> Option<&dyn Thunk>

Thunk view, if the object is a deferred computation.

fn as_list(&self) -> Option<&(dyn ListValue + 'static)>

List view, if the object is a list value.

fn as_table_impl(&self) -> Option<&(dyn Table + 'static)>

Table-implementation view, if the object is a table.

fn as_dir(&self) -> Option<&(dyn Dir + 'static)>

Directory view, if the object is a directory.

fn as_expr(&self, cx: &mut Cx) -> Result<Expr, Error>

Expression form of the object; defaults to an opaque extension node.

fn truth(&self, _cx: &mut Cx) -> Result<bool, Error>

Truthiness of the object; defaults to true.

fn publish_shape_satisfaction_claims( &self, _cx: &mut Cx, _shape: &Ref, ) -> Result<bool, Error>

Publish claims asserting that the object satisfies shape; returns whether any were published.

fn as_table(&self, cx: &mut Cx) -> Result<Value, Error>

Project the object into a table value; the default exposes its display.