FluentAI Language Guide

// Immutable variable (default)
let name = "Alice";
// name = "Bob";  // Error! Cannot reassign

// Mutable variable
let mut counter = 0;
counter := counter + 1;  // OK, using assignment operator

// Type annotations (optional with inference)
let age: int = 30;
let price: float = 19.99;
let active: bool = true;

// Statements require semicolons
let x = 10;
let y = 20;
$(x + y).print();

// Last expression in block - no semicolon needed
let result = {
    let a = 5;
    let b = 10;
    a + b  // This is the block's return value
};

// Control flow blocks don't need semicolons after closing braces
if (condition) {
    doSomething();
} else {
    doSomethingElse();
}  // No semicolon after the closing brace

const PI = 3.14159;
const MAX_CONNECTIONS = 100;
const API_URL = "https://api.fluentai.dev";

let name = "Alice";
let age = 30;

// F-strings for interpolation
let message = f"Hello, {name}! You are {age} years old.";
let calculation = f"Next year you'll be {age + 1}.";

// Basic function
private function add(a: int, b: int) -> int {
    a + b  // Implicit return
}

// With explicit return
public function factorial(n: int) -> int {
    if (n <= 1) {
        return 1;
    }
    n * factorial(n - 1)
}

// Generic function
private function identity(value: T) -> T {
    value
}

// Single parameter
let double = (x) => x * 2;

// Multiple parameters
let add = (a, b) => a + b;

// With type annotations
let divide = (a: float, b: float) => a / b;

// Block body
let complex = (x) => {
    let temp = x * 2;
    temp + 10
};

// Functions as parameters
private function apply_twice(f: (T) -> T, value: T) -> T {
    f(f(value))
}

let result = apply_twice((x) => x * 2, 5);  // 20

// Functions returning functions
private function make_adder(n: int) -> (int) -> int {
    (x) => x + n
}

let add5 = make_adder(5);
let result = add5(10);  // 15

// Matching on enums
result.match()
    .case(Ok(value), => process(value))
    .case(Err(error), => handle_error(error))
    .get();

// Matching with values
status_code.match()
    .case(200, => "Success")
    .case(404, => "Not Found")
    .case(500, => "Server Error")
    .default(=> "Unknown")
    .get();

// Struct destructuring
user.match()
    .case({name, age, email}, => {
        $(f"User: {name}, {age} years old").print();
        send_email(email)
    })
    .get();

// List patterns
list.match()
    .case([], => "Empty list")
    .case([x], => f"Single element: {x}")
    .case([first, ...rest], => f"First: {first}, rest: {rest}")
    .get();

// Guards add conditions to patterns
person.match()
    .case({age}, => age >= 65, => "Senior")
    .case({age}, => age >= 18, => "Adult")
    .case({age}, => "Minor")
    .get();

// Chaining transformations
let result = users
    .filter(user => user.active)
    .map(user => user.score)
    .filter(score => score > 80)
    .fold(0, (sum, score) => sum + score);

// Complex pipeline
orders
    .filter(order => order.status == "completed")
    .map(order => order.items)
    .flatten()
    .group_by(item => item.category)
    .map_values(items => items.len())
    .sort_by_value()
    .take(10);

// Safe navigation with ?
let email = user.profile?.contact?.email;

// Chaining with optionals
config
    .get("database")?
    .get("connection")?
    .get("timeout")
    .unwrap_or(30);

// In user_service.fc
public struct User {
    id: Uuid,
    pub name: string,
    email: string  // private by default
}

public function create_user(name: string, email: string) -> User {
    User {
        id: Uuid.new(),
        name: name,
        email: email
    }
}

private function validate_email(email: string) -> bool {
    email.contains("@")
}

// Import entire module
use my_app::user_service;

let user = user_service.create_user("Alice", "alice@example.com");

// Import specific items
use my_app::user_service::{User, create_user};

// Import with alias
use my_app::database::connection as db;

// I/O effects
perform IO.print("Starting process...");
let content = perform IO.read_file("data.txt");
perform IO.write_file("output.txt", processed_data);

// State effects
perform State.set("counter", 0);
let count = perform State.get("counter");
perform State.update("counter", (n) => n + 1);

// Time effects
let now = perform Time.now();
perform Time.sleep(1000);  // milliseconds

// Custom effect handling
handle {
    let data = process_with_logging();
    save_results(data)
} with {
    Log.debug(msg) => if (DEBUG) { console.log(f"[DEBUG] {msg}") },
    Log.info(msg) => console.log(f"[INFO] {msg}"),
    Log.error(msg) => console.error(f"[ERROR] {msg}")
}

// Mocking effects for testing
handle {
    let user = fetch_user_from_api(id);
    assert_eq(user.name, "Test User")
} with {
    Http.get(url) => Ok({name: "Test User", id: 123})
}

// Functions that can fail return Result
private function divide(a: float, b: float) -> Result {
    if (b == 0) {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

// Chaining with Result
divide(10, 2)
    .map(x => x * 2)
    .and_then(x => divide(x, 3))
    .unwrap_or(0);

// Using ? for early return
private function calculate(input: string) -> Result {
    let parsed = parse_float(input)?;  // Returns early if Err
    let validated = validate_range(parsed)?;
    let result = complex_calculation(validated)?;
    Ok(result)
}

// Combining multiple Results
let total = result1
    .and_then(|v1| result2.map(|v2| v1 + v2))
    .or_else(|_| Ok(default_value));

public trait Drawable {
    private function draw(self) -> unit;
    private function get_bounds(self) -> Rectangle;
}

public trait Serializable {
    private function to_json(self) -> string;
    private function from_json(json: string) -> Result;
}

public struct Circle {
    center: Point,
    radius: float
}

private Circle as Drawable {
    private function draw(self) -> unit {
        // Drawing implementation
        perform Graphics.draw_circle(self.center, self.radius);
    }
    
    private function get_bounds(self) -> Rectangle {
        Rectangle {
            x: self.center.x - self.radius,
            y: self.center.y - self.radius,
            width: self.radius * 2,
            height: self.radius * 2
        }
    }
}