API Reference

let items = [1, 2, 3]

items.len()                  // 3
items.push(4)                // [1, 2, 3, 4]
items.pop()                  // Some(4)
items.map(x => x * 2)        // [2, 4, 6]
items.filter(x => x > 1)     // [2, 3]
items.reduce(0, (a, b) => a + b)  // 6
items.contains(2)            // true
items.is_empty()             // false
items.first()                // Some(1)
items.last()                 // Some(3)

let data = {"name": "Alice", "age": "30"}

data.get("name")            // Some("Alice")
data.insert("city", "NYC") // adds key-value
data.remove("age")          // removes key
data.contains_key("name")  // true
data.keys()                 // ["name", "city"]
data.values()               // ["Alice", "NYC"]
data.len()                  // 2

let tags = {"rust", "ai", "web"insert("api")          // adds element
tags.remove("web")          // removes element
tags.contains("ai")        // true
tags.union(other_set)       // set union
tags.intersection(other)   // set intersection

// Store a memory (episodic by default)
self.anima.remember(key, value)
self.anima.remember(key, value, type: MemoryType::Semantic)

// Recall memories by query
let memories = self.anima.recall_for(query, limit: 5)

// Recall by similarity (semantic search)
let similar = self.anima.recall_similar(embedding, limit: 10)

// Get specific memory by key
let memory = self.anima.recall(key)  // Option<Memory>

// Forget a memory
self.anima.forget(key)

// Form a belief with confidence (0.0-1.0)
self.anima.believe("user_prefers_dark_mode", true, confidence: 0.85)

// Get a belief
let belief = self.anima.beliefs.get("user_prefers_dark_mode")
// Returns Belief { value: true, confidence: 0.85 }

// Check if belief exceeds threshold
if self.anima.beliefs.confident("key", threshold: 0.7) {
    // Act on confident belief
}

// Revise belief with new evidence
self.anima.revise("deadline", "Monday", evidence: 0.9)

// List all beliefs
let all_beliefs = self.anima.beliefs.all()

// Share knowledge with the hive (50% confidence threshold)
hive.mnemonic.learn(insight, confidence: 0.75)

// Query shared knowledge
let shared = hive.mnemonic.recall_for(query, limit: 10)

// Get shared beliefs
let hive_belief = hive.mnemonic.beliefs.get("project_deadline")

// Promote individual memory to shared
hive.mnemonic.promote(self.anima.recall("discovery"))

// Subscribe to hive updates
hive.mnemonic.on_learn(|memory| {
    println("Hive learned: {}", memory.key)
})

// Basic inference using hive SLM
let response = infer(prompt)

// Inference with memory context
let memories = self.anima.recall_for(query, limit: 5)
let response = infer(prompt, context: memories)

// Inference with system prompt
let response = infer(prompt, system: "You are a helpful analyst.")

// Extract structured data into a type
struct Invoice {
    vendor: String,
    amount: f64,
    date: Date,
}

let invoice = infer<Invoice>(document)

// Classify into enum variants
enum Sentiment { Positive, Negative, Neutral }
let sentiment = infer<Sentiment>(text)

let maybe: Option<i64> = Some(42)

maybe.unwrap()              // 42 (panics if None)
maybe.unwrap_or(0)          // 42 (returns 0 if None)
maybe.is_some()             // true
maybe.is_none()             // false
maybe.map(x => x * 2)       // Some(84)

let result: Result<i64, Error> = Ok(42)

result.unwrap()             // 42 (panics if Err)
result.unwrap_or(0)         // 42 (returns 0 if Err)
result.is_ok()              // true
result.is_err()             // false

// Propagate errors with ?
fn process() -> Result<Data, Error> {
    let data = load_data()?   // returns early if Err
    Ok(transform(data))
}