Struct Namespace 

pub struct Namespace {
    pub defs: Defs,
    pub subtypes: SymbolDefs,
    pub choices: SymbolDefs,
    pub conjuncts: Vec<Dict>,
    pub conjuncts_keys: BTreeMap<String, Vec<Vec<String>>>,
    pub features: Vec<Dict>,
    pub libs: Vec<Dict>,
    pub feature_names: Vec<String>,
    pub tag_on_names: Vec<String>,
    pub tag_on_defs: SymbolDefs,
    /* private fields */
}

The container of the normalized definitions.

Fields

defs: Defs

Collection of normalized defs.

subtypes: SymbolDefs

Symbol to subtype defs.

choices: SymbolDefs

Symbols to subtypes for all defs that are choices.

conjuncts: Vec<Dict>

A list of all available conjunct defs.

conjuncts_keys: BTreeMap<String, Vec<Vec<String>>>

features: Vec<Dict>

A list of feature defs.

libs: Vec<Dict>

A list of all the libs implemented by this namespace.

feature_names: Vec<String>

tag_on_names: Vec<String>

A list of all the tagOn names.

tag_on_defs: SymbolDefs

A object that maps def names to their respective tagOn defs.

Implementations

impl Namespace

pub fn make(defs: Grid) -> Self

Constructs a new namespace

Arguments

• defs The normalized defs grid

pub fn get(&self, symbol: &Symbol) -> Option<&Dict>

Return a def via its symbol if it can’t be found.

pub fn get_by_name(&self, name: &str) -> Option<&Dict>

Return a def via its name if it can’t be found.

pub fn has_name(&self, name: &str) -> bool

Return true if the def name exists in the namespace.

pub fn has(&self, symbol: &Symbol) -> bool

Return true if the def exists in the namespace.

pub fn all_matching_names(&self, names: &[&str]) -> Vec<&Dict>

Return a list of defs matching the names.

pub fn is_conjunct(symbol: &Symbol) -> bool

True if the name is for a conjunct.

pub fn conjuncts_defs(&self, symbol: &Symbol) -> Vec<&Dict>

Decomposes a conjunct into its respective defs and returns them

pub fn is_feature(symbol: &Symbol) -> bool

True if the name is for a feature.

pub fn subtypes_of(&self, symbol: &Symbol) -> &Vec<Dict>

Returns the subtypes of the type.

pub fn has_subtype(&self, symbol: &Symbol) -> bool

True if the def has subtypes.

pub fn all_subtypes_of(&self, symbol: &Symbol) -> Vec<&Dict>

Returns a flattened list of all the subtypes.

Arguments

• symbol The def to get the subtypes of

Returns

All subtypes

pub fn supertypes_of(&self, symbol: &Symbol) -> Vec<&Dict>

Returns the direct supertypes (immediate is parents) of a def.

pub fn all_supertypes_of(&self, symbol: &Symbol) -> Vec<&Dict>

Returns a flattened list of all the supertypes in the whole supertype chain.

pub fn choices_for(&self, symbol: &Symbol) -> &Vec<Dict>

Returns a list of choices for def.

pub fn inheritance(&self, symbol: &Symbol) -> Vec<&Dict>

Return the defs inheritance as a flattened array of defs (self + all ancestors).

pub fn associations(&self, parent: &Symbol, association: &Symbol) -> Vec<&Dict>

Return a list of defs for the given association on the parent.

Arguments

• parent The parent def.
• association The association.

pub fn is(&self, parent: &Symbol) -> Vec<&Dict>

Return a vector of defs for the is association on the parent.

Arguments

• parent The parent def

Return

The is association defs

pub fn tag_on(&self, parent: &Symbol) -> Vec<&Dict>

Return a vector of defs for the tagOn association on the parent.

Arguments

• parent The parent def

Return

The tagOn association defs

pub fn tags(&self, parent: &Symbol) -> Vec<&Dict>

Return a vector of defs for the tags association on the parent.

Arguments

• parent The parent def

Return

The tags association defs

pub fn reflect<'a>(&'a self, subject: &Dict) -> Reflection<'a>

Return the defs implemented by the subject dict.

Arguments

• subject The subject to reflect

Return

The reflected defs

pub fn def_of_dict(&self, subject: &Dict) -> &Dict

pub fn fits(&self, def: &Symbol, base_def: &Symbol) -> bool

Return true if the specified def fits the base def.

If true this means that def is assignable to types of base_def. This is effectively the same as checking if inheritance(def) contains base.

Arguments

• def The symbol to check
• def_base The base definition

Returns

True if the def fits the base def.

pub fn fits_marker(&self, def: &Symbol) -> bool

Return true if the specified def is a marker.

Arguments

• def The symbol to check

Returns

True if the def is a marker.

pub fn fits_val(&self, def: &Symbol) -> bool

Return true if the specified def is a val.

Arguments

• def The symbol to check

Returns

True if the def is a value.

pub fn fits_choice(&self, def: &Symbol) -> bool

Return true if the specified def is a choice.

Arguments

• def The symbol to check

Returns

True if the def is a choice.

pub fn fits_entity(&self, def: &Symbol) -> bool

Return true if the specified def is a entity.

Arguments

• def The symbol to check

Returns

True if the def is a entity.

pub fn implementation(&self, def: &Symbol) -> Vec<&Dict>

Return the tags that should be added for implementation.

Arguments

• name The def name.

Returns

An array of defs to be added.

pub fn protos(&self, parent: &Dict) -> Vec<Dict>

Return a reflected list of children prototypes for the parent dict.

Arguments

• parent The parent dict.

Returns

A list of children.

pub fn core_type_defs(&self) -> CoreTypeDefs<'_>

The defs for all of the core haystack value types.

pub fn has_relationship<F: Fn(&Ref) -> Option<Dict>>( &self, subject: &Dict, rel_name: &Symbol, rel_term: &Option<Symbol>, ref_target: &Option<Ref>, resolve: &F, ) -> bool

Query a subject’s relationship.

Relationships model how entities are related to one another via instance to instance relationships versus def to def associations.

https://project-haystack.dev/doc/docHaystack/Relationships#querying

Arguments

• subject The subject dict being queried.
• rel_name The name of the relationship to query.
• rel_term An optional relationship term to query against.
• target_ref An optional reference target.
• resolve An optional function that can resolve dicts (records) from a ref.

Returns

True if a match is made.

Trait Implementations

impl Debug for Namespace

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

Formats the value using the given formatter.

impl Default for Namespace

fn default() -> Namespace

Returns the “default value” for a type.