Struct FnDecl 

pub struct FnDecl {
    pub name: String,
    pub type_params: Vec<String>,
    pub params: Vec<Param>,
    pub effects: Vec<Effect>,
    pub effect_row_var: Option<String>,
    pub return_type: TypeExpr,
    pub body: Block,
    pub examples: Vec<Example>,
    pub leading_comments: Vec<String>,
}

Fields

name: String

type_params: Vec<String>

params: Vec<Param>

effects: Vec<Effect>

effect_row_var: Option<String>

Optional open-row tail on the declared effect row (effect-row poly): -> [io, net | E] T names a row variable E (one of type_params) standing for “plus any further effects”, making the function effect-row-polymorphic. None for the usual closed row. Serialized only when present so pre-feature signatures (and their SigId content hashes) stay byte-identical.

return_type: TypeExpr

body: Block

examples: Vec<Example>

Optional examples { call(a, b) => expected, ... } block (#369). Each case binds the function on literal-or-pure arguments and declares the value the body is expected to produce. Pure-only in v1: a function carrying examples must declare no effects. Serialized as an empty Vec so the JSON shape stays compatible with pre-#369 signatures when the block is absent.

leading_comments: Vec<String>

Comments immediately preceding this fn declaration. See Import for semantics.

Trait Implementations

impl Clone for FnDecl

fn clone(&self) -> FnDecl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FnDecl

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FnDecl

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FnDecl

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

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 FnDecl