Struct Operators 

pub struct Operators { /* private fields */ }

Canonical operator registry.

Use Operators::register to add host-specific operators (typically x.*).

Implementations

impl Operators

pub fn new() -> Self

Build the default canonical operator registry.

Examples found in repository

examples/run_data_eng.rs (line 34)

fn main() {
    let mut doc = read_program(WRANGLE_SCRIPT).unwrap_or_else(|e| {
        eprintln!("parse: {:?}", e);
        process::exit(1);
    });

    // Inject data from Rust (e.g. from DB, file, API)
    let raw_data = json!([
        { "region": "APAC", "amount": 100, "product": "A" },
        { "region": "EMEA", "amount": 50, "product": "B" },
        { "region": "APAC", "amount": 80, "product": "A" },
        { "region": "Americas", "amount": 120, "product": "C" },
        { "region": "EMEA", "amount": 30, "product": "B" },
        { "region": "APAC", "amount": 60, "product": "C" },
    ]);
    doc["state"]["server"] = json!({ "raw_data": raw_data });

    let program = parse_program(&doc).unwrap_or_else(|e| {
        eprintln!("validate: {} - {}", e.code, e.message);
        process::exit(1);
    });
    let operators = Operators::new();
    let out = execute_program(&program, &operators).unwrap_or_else(|e| {
        eprintln!("run: {} - {}", e.code, e.message);
        process::exit(1);
    });

    println!("server.result (by region: count, total amount, desc):");
    println!("{}", serde_json::to_string_pretty(&out.state.server["result"]).unwrap());
}

examples/run_josie.rs (line 32)

fn main() {
    let path = match env::args().nth(1) {
        Some(p) => p,
        None => {
            eprintln!("Usage: run_josie <path.josie>");
            eprintln!("  e.g. cargo run -p josie-core --example run_josie -- examples/hello.josie");
            process::exit(1);
        }
    };
    let src = fs::read_to_string(&path).unwrap_or_else(|e| {
        eprintln!("read {}: {}", path, e);
        process::exit(1);
    });
    let doc = read_program(&src).unwrap_or_else(|e| {
        eprintln!("parse {}: {:?}", path, e);
        process::exit(1);
    });
    let program = parse_program(&doc).unwrap_or_else(|e| {
        eprintln!("validate {}: {} ({})", path, e.code, e.message);
        process::exit(1);
    });
    let operators = Operators::new();
    let out = execute_program(&program, &operators).unwrap_or_else(|e| {
        eprintln!("run {}: {} - {}", path, e.code, e.message);
        process::exit(1);
    });
    println!("value: {}", serde_json::to_string_pretty(&out.value).unwrap());
    let state_json = serde_json::json!({
        "client": out.state.client,
        "server": out.state.server,
    });
    println!("state: {}", serde_json::to_string_pretty(&state_json).unwrap());
}

examples/run_backend.rs (line 61)

fn main() {
    let mut doc = read_program(BACKEND_SCRIPT).unwrap_or_else(|e| {
        eprintln!("parse: {:?}", e);
        process::exit(1);
    });

    // Inject people data (e.g. from DB or API)
    let raw_people = json!([
        {
            "id": 1,
            "first": "Jane",
            "last": "Doe",
            "age": 28,
            "city": "London",
            "country": "UK",
            "email": "jane.doe@example.com",
            "phone": "+44 20 7946 0958",
            "tags": ["customer", "vip"]
        },
        {
            "id": 2,
            "first": "Bob",
            "last": "Smith",
            "age": 34,
            "city": "Berlin",
            "country": "DE",
            "email": "bob.smith@example.com",
            "phone": "+49 30 12345678",
            "tags": ["partner"]
        },
        {
            "id": 3,
            "first": "Alice",
            "last": "Wu",
            "age": 41,
            "city": "Singapore",
            "country": "SG",
            "email": "alice.wu@example.com",
            "phone": null,
            "tags": []
        },
    ]);
    doc["state"]["server"] = json!({ "raw_people": raw_people });

    let program = parse_program(&doc).unwrap_or_else(|e| {
        eprintln!("validate: {} - {}", e.code, e.message);
        process::exit(1);
    });
    let operators = Operators::new();
    let out = execute_program(&program, &operators).unwrap_or_else(|e| {
        eprintln!("run: {} - {}", e.code, e.message);
        process::exit(1);
    });

    println!("server.response (custom JSON shape):");
    println!("{}", serde_json::to_string_pretty(&out.state.server["response"]).unwrap());
}

pub fn get(&self, name: &str) -> Option<Operator>

Lookup an operator by name.

pub fn register( &mut self, name: impl Into<String>, operator: Operator, ) -> Option<Operator>

Register or replace an operator. Returns previous handler if present.

Trait Implementations

impl Default for Operators

fn default() -> Self

Returns the “default value” for a type.