Advanced Topics

// Create a channel with buffer size
let ch = channel(10);

// Unbuffered channel (synchronous)
let sync_ch = channel(0);

// Send values
ch.send(42);
ch.send(100);

// Receive values
let value = ch.receive();  // Blocks until value available
let maybe_value = ch.try_receive();  // Non-blocking, returns Option

// Producer
spawn {
    for i in range(0, 100) {
        ch.send(i * i);
        perform Time.sleep(10);
    }
    ch.close();  // Signal completion
};

// Multiple consumers
for _ in range(0, 3) {
    spawn {
        for value in ch {  // Iterates until channel closed
            process_value(value);
        }
    };
}

// Select from multiple channels
loop {
    select {
        case msg = data_ch.receive() => {
            process_data(msg);
        },
        case cmd = control_ch.receive() => {
            if (cmd == "stop") { break; }
        },
        case timeout(1000) => {
            $(\"No activity for 1 second\").print();
        }
    }
}

// Define async function
private async function fetch_user(id: Uuid) -> Result {
    let response = http.get(f"/api/users/{id}").await();
    response.json().await()
}

// Call async function
async {
    let user = fetch_user(user_id).await();
    match user {
        Ok(u) => update_ui(u),
        Err(e) => show_error(e)
    }
};

// Run multiple async operations concurrently
let (user, posts, comments) = join!(
    fetch_user(user_id),
    fetch_posts(user_id),
    fetch_comments(user_id)
).await();

// Process first completed
let result = race!(
    fetch_from_primary(),
    fetch_from_backup(),
    timeout(5000)
).await();

// Create async stream
private async function* generate_updates() {
    loop {
        let update = fetch_update().await();
        yield update;
        perform Time.sleep(1000);
    }
}

// Consume async stream
async {
    for await update in generate_updates() {
        if (update.is_critical()) {
            handle_critical_update(update);
            break;
        }
    }
}

// Define an actor
private actor Counter {
    // Private state
    count: int = 0;
    
    // Message handlers
    private handle Increment(amount: int) {
        self.count += amount;
    }
    
    private handle Decrement(amount: int) {
        self.count -= amount;
    }
    
    private handle GetCount() -> int {
        self.count
    }
    
    private handle Reset() {
        self.count = 0;
    }
}

// Create actor instance
let counter = Counter.spawn();

// Send messages (async)
counter.send(Increment(5));
counter.send(Decrement(2));

// Request-response pattern
let current = counter.ask(GetCount()).await();
$(f"Current count: {current}").print();

// Actor supervision
let supervised = Counter.spawn_supervised({
    restart_policy: RestartPolicy.Exponential,
    max_restarts: 3
});

// Complex actor system
private actor OrderProcessor {
    orders: Queue = Queue.new();
    workers: List> = [];
    
    private handle Init() {
        // Spawn worker pool
        for i in range(0, 10) {
            self.workers.push(Worker.spawn());
        }
    }
    
    private handle ProcessOrder(order: Order) {
        self.orders.enqueue(order);
        self.distribute_work();
    }
    
    private function distribute_work() {
        while (!self.orders.is_empty()) {
            let order = self.orders.dequeue();
            let worker = self.select_worker();
            worker.send(Process(order));
        }
    }
}

// Spawn a task
spawn {
    perform_long_computation();
};

// Spawn with result
let handle = spawn {
    calculate_result()
};

// Wait for result
let result = handle.join().await();

// Spawn detached (fire and forget)
spawn_detached {
    background_cleanup();
};

// Barrier synchronization
let barrier = Barrier.new(3);

for i in range(0, 3) {
    spawn {
        prepare_data(i);
        barrier.wait();  // Wait for all tasks
        process_synchronized();
    };
}

// WaitGroup pattern
let wg = WaitGroup.new();

for task in tasks {
    wg.add(1);
    spawn {
        process_task(task);
        wg.done();
    };
}

wg.wait();  // Wait for all tasks to complete

// Define contracts
#[requires(n >= 0)]
#[ensures(result >= 1)]
private function factorial(n: int) -> int {
    if (n <= 1) { 1 } else { n * factorial(n - 1) }
}

// Complex contracts
#[requires(list.len() > 0)]
#[ensures(result >= list[0] && result <= list[list.len() - 1])]
private function binary_search(list: List, target: T) -> Option {
    // Implementation
}

// Invariants
#[invariant(balance >= 0)]
private struct Account {
    balance: float,
    transactions: List
}

// Verify contracts with Z3
#[verify]
private function safe_divide(a: int, b: int) -> Option {
    if (b == 0) { None } else { Some(a / b) }
}

// Property-based testing
#[property_test]
private function test_sort_properties(list: List) {
    let sorted = list.sort();
    
    // Length preserved
    assert_eq(sorted.len(), list.len());
    
    // Ordered
    for i in range(0, sorted.len() - 1) {
        assert(sorted[i] <= sorted[i + 1]);
    }
    
    // Same elements
    assert_eq(sorted.sort(), list.sort());
}

// Enable profiling in your VM
let mut vm = VM::new();
vm.enable_profiling(true);

// Run your application
vm.run(program)?;

// Extract profiling data
let profile_data = vm.get_profiler().get_profile_data();

// Profile data includes:
// - Function call counts and execution times
// - Value distributions for specialization
// - Loop iteration counts
// - Memory allocation patterns

// Functions called frequently are automatically inlined
private function compute(x: int) -> int {
    x * 2 + 1  // If called >1000 times, will be inlined
}

// The optimizer detects hot functions and inlines them
let result = data
    .map(x => compute(x))  // compute() inlined here
    .filter(x => x > 10);

// If profiling shows a function is often called with specific values
private function process(mode: string, data: List) -> int {
    match mode {
        "fast" => fast_path(data),    // 80% of calls
        "normal" => normal_path(data), // 15% of calls
        _ => slow_path(data)          // 5% of calls
    }
}

// Optimizer creates specialized versions:
// - process_fast() for the common case
// - process_generic() for other cases

// Loops with predictable iteration counts are unrolled
for i in range(0, 4) {  // Profile shows always 4 iterations
    process(data[i]);
}

// Optimized to:
process(data[0]);
process(data[1]);
process(data[2]);
process(data[3]);

// The optimizer detects pure functions
private function fibonacci(n: int) -> int {
    if (n <= 1) { n }
    else { fibonacci(n-1) + fibonacci(n-2) }
}

// Automatically transformed to:
private function fibonacci_memoized(n: int) -> int {
    static memo_cache = Map::new();
    
    if let Some(result) = memo_cache.get(n) {
        return result;
    }
    
    let result = if (n <= 1) { n }
                 else { fibonacci_memoized(n-1) + fibonacci_memoized(n-2) };
    
    memo_cache.insert(n, result);
    result
}

// Original code with interleaved effects
perform IO.print("Starting");
let x = compute_value();
perform IO.print("Computing");
let y = another_computation();
perform IO.print("Done");

// Optimized: effects batched, pure computations hoisted
let x = compute_value();
let y = another_computation();
perform IO.print("Starting");
perform IO.print("Computing");
perform IO.print("Done");

// Multiple traversals detected
let result = data
    .map(x => x * 2)
    .map(x => x + 1)
    .filter(x => x > 10);

// Fused into single traversal
let result = data
    .filter_map(x => {
        let temp = x * 2 + 1;
        if (temp > 10) { Some(temp) } else { None }
    });

// The optimizer analyzes if values escape their scope
private function process_local() {
    let temp = [1, 2, 3, 4];  // Doesn't escape
    let sum = temp.sum();
    return sum;
}

// temp is stack-allocated instead of heap-allocated

// Functions are reordered based on call patterns
// Hot functions grouped together for better I-cache usage

// Before: Random layout
// function_a() -> 0x1000  (hot)
// function_b() -> 0x2000  (cold) 
// function_c() -> 0x3000  (hot)

// After: Temperature-based layout
// function_a() -> 0x1000  (hot)
// function_c() -> 0x1100  (hot)
// function_b() -> 0x4000  (cold)

// Manual optimization hints
#[inline(always)]
private function hot_path_function(x: int) -> int {
    x * 2 + 1
}

// No allocation hints
#[no_alloc]
private function process_in_place(data: &mut List) {
    for i in range(0, data.len()) {
        data[i] = data[i] * 2;
    }
}

// SIMD hints
#[simd]
private function vector_add(a: List, b: List) -> List {
    a.zip(b).map(|(x, y)| x + y)
}

// Pure function hints for memoization
#[pure]
private function expensive_computation(x: int) -> int {
    // Complex pure computation
}

// Configure optimization pipeline
use fluentai_optimizer::{
    OptimizationConfig, 
    OptimizationLevel,
    RuntimeGuidedConfig
};

// Basic configuration
let config = OptimizationConfig::for_level(
    OptimizationLevel::Aggressive
);

// Custom configuration with profiling data
let runtime_config = RuntimeGuidedConfig {
    hot_functions: profile_data.hot_functions,
    skewed_values: profile_data.skewed_values,
    hot_loops: profile_data.hot_loops,
    hot_function_threshold: 1000,
    value_specialization_threshold: 0.8,
    loop_unroll_threshold: 4.0,
};

// Create optimization pipeline
let pipeline = create_optimization_pipeline(runtime_config);
let optimized_ast = pipeline.optimize(ast)?;

// The compiler automatically detects common patterns
let data = [1, 2, 3, 4, 5]
    .map(x => x * 2)      // Detected: map-reduce pattern
    .filter(x => x > 5)   // Detected: filter-map chain
    .reduce(0, (a, b) => a + b);

// AI suggests optimizations like:
// - Fusion of map and filter operations
// - SIMD vectorization opportunities
// - Parallelization potential

// Enable AI analysis in your build
use fluentai_ai::{analyze_ast, AiAnalyzerBuilder};

// Get optimization suggestions
let analyzer = AiAnalyzerBuilder::new()
    .detect_patterns(true)
    .detect_optimizations(true)
    .build();

let analysis = analyzer.analyze_graph(&ast)?;

// Analysis provides:
// - Performance score (0.0 - 1.0)
// - Detected patterns (map-reduce, recursion, etc.)
// - Optimization opportunities:
//   * Constant folding
//   * Common subexpression elimination
//   * Tail recursion optimization
//   * Dead code elimination

// Features are extracted directly from AST nodes
// No JSON serialization or external dependencies

// Each node provides ML-ready features:
let features = node.metadata.feature_vector();
// Returns normalized features for:
// - Node type and structure
// - Purity analysis
// - Usage statistics
// - Performance hints
// - Context memory

// The AI model operates directly on in-memory AST
// with O(n) complexity and efficient caching

// AI analysis results are injected into AST metadata
let injector = MetadataInjector::new(InjectorConfig {
    inject_optimizations: true,
    inject_patterns: true,
    inject_embeddings: false, // Optional: node embeddings
});

injector.inject(&mut ast, &analysis)?;

// Metadata is available during compilation phases:
// - Optimization passes can use AI suggestions
// - Code generation can leverage pattern information
// - IDE integration for real-time insights

// Available optimization strategies
enum OptimizationStrategy {
    None,           // No optimization (baseline)
    Basic,          // Constant folding, dead code elimination
    Standard,       // + CSE, function inlining
    Aggressive,     // All optimizations enabled
    Custom(u32),    // Bitmask for specific optimizations
}

// Configuration for learning mode
let config = LearningModeConfig {
    hot_threshold: 100,              // Executions before "hot"
    exploration_mode: ExplorationMode::Smart,
    exploration_rate: 0.2,           // 20% exploration
    use_rl_agent: true,             // Use AI for decisions
};

// Exploration modes:
enum ExplorationMode {
    Quick,      // Tests 4 predefined strategies only
    Smart,      // Tests 19 carefully selected combinations
    Exhaustive, // Tests all 8192 possible combinations
}

// Create VM with learning mode enabled
let mut vm = VM::new();
vm.enable_learning_mode(LearningModeConfig::default());

// Run your application
vm.run(program)?;

// Check optimization progress
let stats = vm.get_learning_stats();
$(f"Functions analyzed: {stats.functions_analyzed}").print();
$(f"Hot functions found: {stats.hot_functions}").print();
$(f"Optimized functions: {stats.functions_explored}").print();

// View exploration progress for active optimizations
for (func_id, tested, total) in stats.exploration_progress {
    $(f"Function {func_id}: {tested}/{total} strategies tested").print();
}

struct ExecutionMetrics {
    duration: Duration,           // Execution time
    instruction_count: u64,       // Instructions executed
    allocations: u64,            // Memory allocations
    cache_misses: u64,           // Simulated cache misses
    branch_mispredictions: u64,  // Simulated branch misses
}

// The VM maintains multiple compiled variants
// and automatically selects the best one

// Original function
private function process_data(items: List) -> int {
    items
        .filter(x => x > 0)
        .map(x => x * x)
        .sum()
}

// After learning, the VM might use a variant with:
// - Filter and map operations fused
// - SIMD instructions for squaring
// - Parallel reduction for sum
// All transparently without code changes!

// Fibonacci function that benefits from memoization
private function fib(n: int) -> int {
    if (n <= 1) { n }
    else { fib(n-1) + fib(n-2) }
}

// First execution: No optimization
let start = perform Time.now();
let result1 = fib(40);  // ~5 seconds
$(f"Unoptimized: {perform Time.now() - start}ms").print();

// After 100+ calls, learning mode kicks in
// It detects the function is pure and adds memoization

// Subsequent execution: Optimized with memoization
let start2 = perform Time.now();
let result2 = fib(40);  // ~0.001 seconds
$(f"Optimized: {perform Time.now() - start2}ms").print();

// 5000x speedup achieved automatically!

// Advanced configuration
let config = LearningModeConfig {
    // Function becomes hot after this many calls
    hot_threshold: 100,
    
    // Maximum strategies to try per function
    max_strategies_per_function: 10,
    
    // Save learned optimizations to disk
    save_learned_data: true,
    model_path: Some("optimizations.bin"),
    
    // Exploration vs exploitation rate
    exploration_rate: 0.2,
    
    // Use AI agent for intelligent strategy selection
    use_rl_agent: true,
    
    // How to explore optimization space
    exploration_mode: ExplorationMode::Smart,
};

// Enable detailed optimization logging
vm.set_optimization_log_level(LogLevel::Debug);

// Disable specific optimizations for debugging
let config = LearningModeConfig {
    disabled_optimizations: vec![
        OptimizationPass::Memoization,
        OptimizationPass::FunctionInlining,
    ],
    ..Default::default()
};

// Force a specific strategy for testing
vm.force_optimization_strategy(
    function_id, 
    OptimizationStrategy::Basic
);

// Arena allocation
let arena = Arena.new();
let data = arena.alloc_slice(1000);

// Object pooling
let pool = ObjectPool.new(
    create: || Connection.new(),
    reset: |conn| conn.clear()
);

let conn = pool.get();
// Use connection
pool.return(conn);

// Custom allocators
#[allocator(bump)]
private function build_tree() -> Tree {
    // All allocations use bump allocator
}

// Import C functions
extern "C" {
    private function strlen(s: *const u8) -> usize;
    private function malloc(size: usize) -> *mut u8;
    private function free(ptr: *mut u8);
}

// Export to C
#[export_c]
public function fluentai_process(data: *const u8, len: usize) -> i32 {
    let slice = unsafe { slice_from_raw(data, len) };
    process_data(slice) as i32
}

// WASM exports
#[wasm_export]
public function add(a: i32, b: i32) -> i32 {
    a + b
}

// WASM imports
#[wasm_import("env", "log")]
extern function console_log(msg: *const u8, len: usize);

// WASM memory management
#[wasm_export]
public function allocate(size: usize) -> *mut u8 {
    Box.into_raw(vec![0u8; size])
}