Enum TreeExpansionPolicy

pub enum TreeExpansionPolicy {
    Simple,
    Weighted(WeightedNodeVariantPolicy),
    WeightedWithLimits(WeightedNodeVariantPolicyWithLimits),
    DepthBased(DepthBasedNodeVariantPolicy),
    AlwaysAggregate,
    AlwaysDispatch,
    AlwaysLeafHolder,
    Phased(PhasedNodeVariantPolicy),
    Scripted(ScriptedNodeVariantPolicy),
}

This structure is the primary enum for controlling how we choose among Dispatch, Aggregate, and LeafHolder nodes at each level of the tree generation procedure.

Each variant indicates a strategy for determining the mechanism of choosing the node-kind.

The choice should be made to optimally configure the grower for our target domain. Different domains will require different variant selections here.

It is important for the language model to determine intelligent behavior for its selection.

TODO: here we would like to indicate some useful guidelines about how to do this successfully.

Variants

Simple

This strategy will always pick Dispatch for intermediate nodes (levels < final) and LeafHolder for the final level. It will ignore aggregator nodes entirely. This is the classic “enum tree until depth, then leaves at the bottom.”

Weighted(WeightedNodeVariantPolicy)

At each level, this strategy will randomly pick among aggregator/dispatch/leaf with the given weights. (It has no built-in depth constraints.)

WeightedWithLimits(WeightedNodeVariantPolicyWithLimits)

This strategy is the same as Weighted, but with inline constraints like aggregator max depth, etc.

DepthBased(DepthBasedNodeVariantPolicy)

This strategy will define the level at which aggregator nodes “begin,” as well as the level at which leaf nodes “begin,” with dispatch nodes used before the aggregator nodes start.

Tuple Fields

0: DepthBasedNodeVariantPolicy

Here we need to take into account the characteristics of the target domain in order to choose specifically the levels at which nodes of a particular kind begin and when they *end.

AlwaysAggregate

This strategy will always pick aggregator except for the final level (which presumably is a leaf).

AlwaysDispatch

This strategy will always pick dispatch nodes except for during the final level.

AlwaysLeafHolder

This strategy will force every node to be a leaf, ignoring depth. Typically used for flattening or testing.

Phased(PhasedNodeVariantPolicy)

This strategy will specify a list of “phases,” each determining weights for aggregator/dispatch/leaf generation starting at a given depth, continuing until the next phase or the end.

Tuple Fields

0: PhasedNodeVariantPolicy

Here we need to take into account how many phases are useful for our target domain and what their parameters are.

Scripted(ScriptedNodeVariantPolicy)

This strategy uses a direct “per-level” approach via a map from u8 (level) → aggregator/dispatch/leaf probabilities. If a level is missing, the downstream generator code will fallback or clamp to last known.

Tuple Fields

0: ScriptedNodeVariantPolicy

Here we need to take into account the target domain in order to choose relevant levels and their respective parameters

Trait Implementations

impl AiJsonTemplate for TreeExpansionPolicy

fn to_template() -> Value

Return a JSON template describing how the AI’s output should be structured. This might include doc comments or other instructions for each field.

impl AiJsonTemplateWithJustification for TreeExpansionPolicy

fn to_template_with_justification() -> Value

impl Clone for TreeExpansionPolicy

fn clone(&self) -> TreeExpansionPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TreeExpansionPolicy

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

Formats the value using the given formatter.

impl Default for TreeExpansionPolicy

fn default() -> TreeExpansionPolicy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TreeExpansionPolicy

fn deserialize<__D>( __deserializer: __D, ) -> Result<TreeExpansionPolicy, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<JustifiedTreeExpansionPolicy> for TreeExpansionPolicy

fn from(value: JustifiedTreeExpansionPolicy) -> TreeExpansionPolicy

Converts to this type from the input type.

impl LoadFromFile for TreeExpansionPolicy

where TreeExpansionPolicy: for<'de> Deserialize<'de>,

type Error = SaveLoadError

fn load_from_file<'async_trait>( filename: impl AsRef<Path> + Send + 'async_trait, ) -> Pin<Box<dyn Future<Output = Result<TreeExpansionPolicy, <TreeExpansionPolicy as LoadFromFile>::Error>> + Send + 'async_trait>>

where TreeExpansionPolicy: 'async_trait,

impl PartialEq for TreeExpansionPolicy

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

where TreeExpansionPolicy: Serialize,

type Error = SaveLoadError

fn save_to_file<'life0, 'async_trait>( &'life0 self, filename: impl AsRef<Path> + Send + 'async_trait, ) -> Pin<Box<dyn Future<Output = Result<(), <TreeExpansionPolicy as SaveToFile>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, TreeExpansionPolicy: 'async_trait,

impl Serialize for TreeExpansionPolicy

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TreeExpansionPolicy