Struct StrippedStringSkeleton 

pub struct StrippedStringSkeleton { /* private fields */ }

We want to create a stripped version of our StringSkeleton, called a StrippedStringSkeleton.

The StrippedStringSkeleton should contain a flattened list of all nodes in the model tree.

Each entry in items corresponds to one StrippedNodeData, referencing children by name if any exist.

The StrippedStringSkeleton differs from the StringSkeleton in the following way:

• StringSkeleton represents the full payload.
• In certain cases, we need something lighter. StrippedStringSkeleton fills this niche.
• In a typical system flow, we maintain the StringSkeleton elsewhere and, although it is more computationally intensive, we can refer to it when necessary.

Here we need simply the bare scaffold.

In this structure, we do not need parameter selection justification/confidence levels.

Here we want to track each node by name with its children and its kind {Dispatch,Aggregate,LeafHolder}

• The role of this data structure is to immediately and directly indicate the shape of the model scaffold. The shape of this tree should be exactly the same as the StringSkeleton.

Here we should keep intact the information about whether or not a branch is optional.

Here we track the selection-probability field associated with each branch. We use this probability field to make decisions during randomization about which model paths to traverse and how frequently. The probability field should be set based on domain knowledge about the concrete domain represented by the tree.

Example Output Format

Below is an example for illustration only (note how it avoids referencing a specific domain and uses placeholders instead):

[
  {
    "name": "CoreModule",
    "kind": "Aggregate",
    "descriptor": "Collects baseline components essential for broad functionality.",
    "children": [
      {
        "name": "InitializationBlock",
        "optional": false,
        "probability": 1.0
      },
      {
        "name": "LifecycleHooks",
        "optional": false,
        "probability": 1.0
      }
    ]
  },
  {
    "name": "InitializationBlock",
    "kind": "Dispatch",
    "descriptor": "Switches among methods for setting initial parameters or states.",
    "children": [
      {
        "name": "ParameterSetup",
        "optional": false,
        "probability": 1.0
      },
      {
        "name": "ResourceProvision",
        "optional": false,
        "probability": 1.0
      }
    ]
  },
  {
    "name": "ParameterSetup",
    "kind": "LeafHolder",
    "descriptor": "Defines various ways to assign base parameters before use.",
    "n_leaves": 9
  },
  {
    "name": "ResourceProvision",
    "kind": "LeafHolder",
    "descriptor": "Outlines techniques for supplying necessary resources or data.",
    "n_leaves": 9,
    "capstone": true
  },
  {
    "name": "LifecycleHooks",
    "kind": "LeafHolder",
    "descriptor": "Houses event triggers or callback methods tied to major milestones.",
    "n_leaves": 9
  }
]

When generating this structure, please keep the following information in mind:

1. Output your final stripped skeleton as an array of JSON objects, one per node.
2. For each node:
   • Provide its name, kind, descriptor, and if non-leaf, its children.
   • For leaf nodes, provide n_leaves and capstone if applicable.
3. Make sure descriptors are domain-focused and remain cohesive when read in a hierarchy from root to leaf.
4. No fields other than the ones mentioned: no confidence, no justification, no extraneous data.

By following these guidelines, your descriptors will naturally form a coherent mini-narrative for any domain you apply them to.

Implementations

impl StrippedStringSkeleton

pub fn target_name(&self) -> &String

This field holds verbatim the lower-kebab-case target-name belonging to the tree grow process.

pub fn items(&self) -> &Vec<StrippedNodeData>

The complete list of nodes in the scaffold.

We require that the full shape of the original StringSkeleton is maintained, including all of its nodes and branches to full depth.

impl StrippedStringSkeleton

pub fn set_target_name(&mut self, val: String) -> &mut Self

This field holds verbatim the lower-kebab-case target-name belonging to the tree grow process.

pub fn set_items(&mut self, val: Vec<StrippedNodeData>) -> &mut Self

The complete list of nodes in the scaffold.

We require that the full shape of the original StringSkeleton is maintained, including all of its nodes and branches to full depth.

Trait Implementations

impl AiJsonTemplate for StrippedStringSkeleton

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 Clone for StrippedStringSkeleton

fn clone(&self) -> StrippedStringSkeleton

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StrippedStringSkeleton

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StrippedStringSkeleton

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StrippedStringSkeleton

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

Formats the value using the given formatter.

impl Eq for StrippedStringSkeleton

impl From<&StringSkeleton> for StrippedStringSkeleton

Below is our updated From<&StringSkeleton> for StrippedStringSkeleton implementation. We simply call promote_missing_child_nodes_with_defaults at the start, so that none of the aggregator/dispatch children get dropped. After that, the existing logic remains unchanged.

Make sure to import the promote_missing_child_nodes_with_defaults function in whatever module houses this impl.

fn from(x: &StringSkeleton) -> Self

Converts to this type from the input type.

impl From<JustifiedStringSkeleton> for StrippedStringSkeleton

fn from(x: JustifiedStringSkeleton) -> Self

Converts to this type from the input type.

impl Hash for StrippedStringSkeleton

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LoadFromFile for StrippedStringSkeleton

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

type Error = SaveLoadError

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

where Self: 'async_trait,

impl PartialEq for StrippedStringSkeleton

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

where StrippedStringSkeleton: Serialize,

type Error = SaveLoadError

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

where Self: 'async_trait, 'life0: 'async_trait,

impl Serialize for StrippedStringSkeleton

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 StrippedStringSkeleton