Puffin Programming Language

# Puffin: Lexical scoping, domain stdlib, typed collections & actor concurrency
:>inc "std/text/strings.pfn"

struct Metric { name: str, value: f64 }

namespace Telemetry {
    HATCH {
        static active_events = 0
    }

    export function record(name, val) {
        active_events++
        let tag = std.text.strings.upper(name)

        # Typed collections (@Dict / @List) & variant constructors
        return Ok(@Dict[
            "id": active_events,
            "metric": Metric(tag, val),
            "tags": @List["production", "telemetry"],
            "verified": true
        ])
    }
}

BEGIN {
    # Cooperative actor spawning over isolated message channels
    let worker = hatch coop Telemetry()

    # Functional pipelines with first-class arrow lambdas
    let raw = @List["cpu_load", "mem_peak", "io_wait"]
    let metrics = raw
        |> map(x -> std.text.strings.lower(x))
        |> filter(x -> Length(x) > 0)

    # Typed non-blocking RPC with Result variant matching
    case await worker.record("node_health", 99.8) {
        Ok(report): {
            print "Worker Ready -> Event ID:", report["id"]
            for k, v in report {
                print "  ", k, "=>", v
            }
        }
        Err(err): {
            print "Worker Error:", err
        }
    }
}