Struct Signature 

pub struct Signature<PT: ProtocolTypes> {
    pub functions_by_name: HashMap<&'static str, FunctionDefinition<PT>>,
    pub functions_by_typ: HashMap<TypeShape<PT>, Vec<FunctionDefinition<PT>>>,
    pub functions: Vec<FunctionDefinition<PT>>,
    pub types_by_name: HashMap<&'static str, TypeShape<PT>>,
    pub attrs_by_name: HashMap<&'static str, FunctionAttributes>,
    min_cost_by_name: HashMap<&'static str, Cost>,
    min_cost_by_typ: HashMap<TypeShape<PT>, Cost>,
    functions_by_typ_by_depth: HashMap<TypeShape<PT>, DepthOrdered<PT>>,
}

Records a universe of functions. Signatures are containers for types and function symbols. They hold references to the concrete implementations of functions and the types of variables.

Fields

functions_by_name: HashMap<&'static str, FunctionDefinition<PT>>

functions_by_typ: HashMap<TypeShape<PT>, Vec<FunctionDefinition<PT>>>

functions: Vec<FunctionDefinition<PT>>

types_by_name: HashMap<&'static str, TypeShape<PT>>

attrs_by_name: HashMap<&'static str, FunctionAttributes>

min_cost_by_name: HashMap<&'static str, Cost>

Minimal generation depth and size per function symbol, see Self::min_gen_depth and Self::min_gen_size.

min_cost_by_typ: HashMap<TypeShape<PT>, Cost>

Minimal generation depth and size per type, see Self::min_gen_depth_of_type and Self::min_gen_size_of_type.

functions_by_typ_by_depth: HashMap<TypeShape<PT>, DepthOrdered<PT>>

Per type, the symbols returning it, ordered by increasing minimal depth, see Self::choose_function_within.

Implementations

impl<PT: ProtocolTypes> Signature<PT>

pub fn new( definitions: Vec<(FunctionDefinition<PT>, FunctionAttributes)>, ) -> Self

Construct a Signature from the given FunctionDefinitions.

fn compute_min_costs( definitions: &[(FunctionDefinition<PT>, FunctionAttributes)], ) -> (HashMap<&'static str, Cost>, HashMap<TypeShape<PT>, Cost>)

Least fixed point of

• depth(f) = 1 + max { depth(t) | t argument type of f } (so 1 for a constant),
• size(f) = 1 + sum { size(t) | t argument type of f } (so 1 for a constant),
• cost(t) = the pointwise min over the symbols returning t.

Symbols with an argument type no function can build, and the types only such symbols return, are absent from the returned maps: no closed term exists for them at any cost.

pub fn min_gen_depth(&self, name: &str) -> Option<u16>

The minimal depth at which the term zoo can build a closed term rooted at name: 1 for a constant, 1 + max over the argument types otherwise. Matches the budget accounting of crate::fuzzer::term_zoo, so a generation attempt for name with a budget below this can only fail.

None when no closed term is rooted at name at any depth (some argument type has no closed term), which also means name is unknown to this signature.

pub fn min_gen_size(&self, name: &str) -> Option<usize>

The size, in nodes, of the smallest closed term rooted at name: 1 for a constant, 1 + sum over the argument types otherwise. Same conventions as Self::min_gen_depth.

pub fn min_gen_depth_of_type(&self, typ: &TypeShape<PT>) -> Option<u16>

Same as Self::min_gen_depth, for the shallowest closed term of the given type.

pub fn min_gen_size_of_type(&self, typ: &TypeShape<PT>) -> Option<usize>

Same as Self::min_gen_size, for the smallest closed term of the given type.

Note this is a lower bound rather than an achievable cost: the shallowest and the smallest term of a type need not be the same one, and the two components are minimised separately.

pub fn choose_function_within<R: Rand>( &self, typ: &TypeShape<PT>, depth: u16, size: usize, rand: &mut R, ) -> Option<&FunctionDefinition<PT>>

Uniformly picks a symbol of the given type that the term zoo can build a closed term for within depth levels and size nodes.

None when the type is unknown or when no symbol of that type is that cheap.

pub fn new_function<F: 'static + DescribableFunction<PT, Types>, Types>( f: &'static F, ) -> Function<PT>

Create a new Function distinct from all existing Functions.

pub fn new_var_with_type<T: 'static, M: Matcher>( source: Option<Source>, matcher: Option<M>, counter: u16, ) -> Variable<PT>

where PT: ProtocolTypes<Matcher = M>,

pub fn new_var<M: Matcher>( type_shape: TypeShape<PT>, source: Option<Source>, matcher: Option<M>, counter: u16, ) -> Variable<PT>

where PT: ProtocolTypes<Matcher = M>,

Trait Implementations

impl<PT: ProtocolTypes> Debug for Signature<PT>

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

Formats the value using the given formatter.