Language Specification

import network::tcp;                         // Import moduleimport network::tcp::Connection;             // Import specific symbolimport network::tcp::{Connection, connect};  // Import multipleimport network::tcp::*;                      // Import all public symbols

let x = 5;          // immutable — cannot reassignvar y = 5;          // mutable — can reassignconst MAX: i32 = 100;  // compile-time constanty = 10;             // ok// x = 10;          // compile error

fn add(a: i32, b: i32) -> i32 {    a + b}fn max<T: Ord>(a: T, b: T) -> T {    if a > b { a } else { b }}

struct Point { x: f64, y: f64 }struct Config {    let name: String;     // immutable field    var retries: i32 = 3; // mutable field with default}enum Shape {    Circle(f64);    Rectangle { width: f64, height: f64 };    Unit;}

fn merge<K, V>(a: Map<K, V>, b: Map<K, V>) -> Map<K, V>where    K: Hash + Eq + Send,    V: Clone + Send,{    // implementation}

trait Display {    fn display(self) -> String;}trait Iterator {    type Item;    fn next(self) -> Option<Self::Item>;}struct Point { x: f64, y: f64 }impl Display for Point {    fn display(self) -> String {        f"({self.x}, {self.y})"    }}

fn log_anything(item: dyn Display) {    print(item.display());}// Multiple trait boundsfn process(item: dyn(Display + Clone)) {    // ...}

// Arrow syntaxlet doubled = numbers.map((x) => x * 2);// Pipe syntax (equivalent)let doubled = numbers.map(|x| x * 2);// With type annotationslet f: fn(i32, i32) -> i32 = (x, y) => x + y;// Move capturelet config = load_config();let worker = spawn move (msg: Msg) => { use(config); };

fn read_file(path: String) -> Result<String, IoError> {    let handle = open(path)?;   // propagate on error    let content = read(handle)?;    Ok(content)}let result = try {    dangerous_operation()?;    Ok(value)};

// If expressionlet status = if count > 0 { "active" } else { "idle" };// Match expressionmatch shape {    Circle(r) => 3.14 * r * r,    Rectangle { width, height } => width * height,    Unit => 0.0,}// Labeled loop'outer: loop {    for item in items {        if item.done { break 'outer; }    }}

match value {    0 | 1 => println("zero or one"),    n if n < 0 => println("negative"),    n => println(f"positive: {n}"),}// Struct destructuringmatch point {    Point { x: 0, y } => println(f"on y-axis at {y}"),    Point { x, y: 0 } => println(f"on x-axis at {x}"),    Point { x, y } => println(f"({x}, {y})"),}// Nested constructor patternsmatch result {    Ok(Some(value)) => use(value),    Ok(None) => println("empty"),    Err(e) => println(f"error: {e}"),}

actor Counter {    var count: i32 = 0;    mailbox 256;    // Fire-and-forget: no return type, no await needed    receive fn increment(n: i32) {        self.count += n;    }    // Request-response: has return type, caller must await    receive fn get() -> i32 {        self.count    }    fn validate(n: i32) -> bool { n >= 0 }}let counter = spawn Counter { count: 0 };counter.increment(10);            // fire-and-forgetlet n = await counter.get();      // request-response

// Fire-and-forget lambda actorlet worker = spawn (msg: i32) => { println(msg * 2); };worker <- 42;// Request-response lambda actorlet calc = spawn (x: i32) -> i32 => { x * x };let result = await calc <- 5;// With move capturelet factor = 2;let multiplier = spawn move (x: i32) -> i32 => { x * factor };

supervisor AppSupervisor {    child db: DatabaseActor        restart(permanent)        budget(5, 30.s)        strategy(one_for_one);    child cache: CacheActor        restart(transient);    child logger: LogActor        restart(temporary);}

scope {    let a = scope.spawn { fetch_user(id1) };    let b = scope.spawn { fetch_user(id2) };    // Both run concurrently    let user1 = await a;    let user2 = await b;    merge_users(user1, user2)}

let result = select {    count from counter.get_count() => count * 2,    data from worker.get_data() => data.len,    after 1.seconds => -1,};

let fastest = race {    server1.fetch(key),    server2.fetch(key),    server3.fetch(key),    after 5.seconds => Err(Timeout),};

let (users, posts, stats) = join {    db.fetch_users(),    db.fetch_posts(),    analytics.get_stats(),};

let result = await counter.get_count() | after 1.seconds;// result: Result<i32, Timeout>

wire struct User {    name: string @1;    email: string @2;    age: u32 @3 optional;    role: Role @4 default(Role::Member);    reserved(5, 6);  // deleted fields}wire enum Role {    Admin;    Member;    Guest;}

foreign "C" {    fn malloc(size: usize) -> *mut u8;    fn free(ptr: *mut u8);    fn printf(fmt: *const u8, ...) -> i32;}fn allocate(size: usize) -> *mut u8 {    unsafe { malloc(size) }}#[export("hew_process")]foreign "C" fn process(data: *const u8, len: usize) -> i32 {    // callable from C as hew_process()}

// Integerslet dec = 1_000_000;let hex = 0xFF;let bin = 0b1010;// Floatslet pi = 3.14;let sci = 1.5e10;// Stringslet s = "hello\nworld";let raw = r"no escapes here";let interp = f"count is {count + 1}";// Durationslet timeout = 500.ms;let interval = 1.s;let budget = 30.s;

(* Comments *)
Comment        = LineComment | BlockComment | DocComment ;
LineComment    = "//" { AnyChar } Newline ;
BlockComment   = "/*" { AnyChar } "*/" ;
DocComment     = "///" { AnyChar } Newline ;

(* Program structure *)
Program        = { Item } ;

Item           = Attribute* Visibility? ( Import
                             | ConstDecl
                             | LetDecl
                             | VarDecl
                             | TypeDecl
                             | TraitDecl
                             | ImplDecl
                             | WireDecl
                             | FnDecl
                             | ExternBlock
                             | ActorDecl
                             | SupervisorDecl ) ;

(* Module-level bindings *)
LetDecl        = "let" Ident ( ":" Type )? "=" Expr ";" ;
VarDecl        = "var" Ident ( ":" Type )? "=" Expr ";" ;

Visibility     = "pub" ( "(" VisScope ")" )? ;
VisScope       = "package" | "super" ;

(* Attributes *)
Attribute      = "#[" AttrContent "]" ;
AttrContent    = Ident ( "(" AttrArgs ")" )? ;
AttrArgs       = AttrArg { "," AttrArg } ;
AttrArg        = Ident | StringLit | Ident "=" (StringLit | Ident) ;

(* Module system *)
Import         = "import" ModulePath ( "::" ImportSpec )? ";" ;
ModulePath     = Ident { "::" Ident } ;
ImportSpec     = Ident
               | "{" Ident { "," Ident } "}"
               | "*" ;

(* Constants and types *)
ConstDecl      = "const" Ident ":" Type "=" Expr ";" ;

TypeDecl       = ("struct" | "enum") Ident TypeParams? WhereClause? TypeBody ;
WireDecl       = "wire" ("struct" | "enum") Ident WireBody ;

TypeParams     = "<" TypeParam { "," TypeParam } ">" ;
TypeParam      = Ident ( ":" TraitBounds )? ;
TraitBounds    = TraitBound { "+" TraitBound } ;
TraitBound     = Ident TypeArgs? ;

WhereClause    = "where" WherePredicate { "," WherePredicate } ;
WherePredicate = Type ":" TraitBounds
               | AssociatedTypeBound ;
AssociatedTypeBound = Type "::" Ident ":" TraitBounds ;

TypeBody       = "{" { FieldDecl | VariantDecl | FnDecl } "}" ;
WireBody       = "{" { WireFieldDecl | VariantDecl } "}" ;

FieldDecl      = ("let" | "var") Ident ":" Type ("=" Expr)? ";" ;
WireFieldDecl  = Ident ":" WireType "@" IntLit WireAttr* ";" ;
WireAttr       = "optional" | "deprecated"
               | ("default" "(" Expr ")") | ReservedDecl ;
ReservedDecl   = "reserved" "(" IntLit { "," IntLit } ")" ;

VariantDecl    = Ident ( "(" TypeList ")" | "{" { FieldDecl } "}" )? ";" ;
TypeList       = Type { "," Type } ;

(* Traits *)
TraitDecl      = "trait" Ident TypeParams? TraitSuper? WhereClause?
                 "{" { TraitItem } "}" ;
TraitSuper     = ":" TraitBounds ;
TraitItem      = FnSig ";"
               | AssociatedType ;
AssociatedType = "type" Ident ( ":" TraitBounds )? ( "=" Type )? ";" ;
FnSig          = "fn" Ident TypeParams? "(" Params? ")" RetType? WhereClause? ;

ImplDecl       = "impl" TypeParams? TraitBound "for" Type WhereClause?
                 "{" { FnDecl | AssociatedTypeImpl } "}" ;
AssociatedTypeImpl = "type" Ident "=" Type ";" ;

(* Actors *)
ActorDecl      = "actor" Ident TypeParams? TraitSuper? WhereClause? "{"
                   ActorInit?
                   MailboxDecl?
                   { FieldDecl | ReceiveFnDecl | FnDecl }
                 "}" ;
ActorInit      = "init" "(" Params? ")" Block ;
MailboxDecl    = "mailbox" IntLit ";" ;
ReceiveFnDecl  = "receive" "fn" Ident TypeParams? "(" Params? ")"
                 RetType? WhereClause? Block ;

(* Supervisors *)
SupervisorDecl = "supervisor" Ident "{" { ChildSpec } "}" ;
ChildSpec      = "child" Ident ":" Ident RestartSpec? ";" ;
RestartSpec    = "restart" "(" ("permanent" | "transient" | "temporary") ")"
                 ("budget" "(" IntLit "," DurationLit ")")?
                 ("strategy" "(" ("one_for_one" | "one_for_all"
                                | "rest_for_one") ")")? ;

(* FFI / Extern declarations *)
ExternBlock    = ("foreign" | "extern") StringLit "{" { ExternFnDecl } "}" ;
ExternFnDecl   = "fn" Ident "(" ExternParams? ")" RetType? Variadic? ";" ;
ExternParams   = ExternParam { "," ExternParam } ;
ExternParam    = Ident ":" Type ;
Variadic       = "..." ;

ExternFnExport = "#[" "export" ( "(" StringLit ")" )? "]" ExternFnDef ;
ExternFnDef    = "foreign" StringLit "fn" Ident "(" Params? ")" RetType? Block ;

(* Functions *)
FnDecl         = "async"? "fn" Ident TypeParams? "(" Params? ")"
                 RetType? WhereClause? Block ;
Params         = Param { "," Param } ;
Param          = Ident ":" Type ;
RetType        = "->" Type ;

(* Unsafe blocks *)
UnsafeBlock    = "unsafe" Block ;

(* Statements *)
Block          = "{" { Stmt } Expr? "}" ;

Stmt           = LetStmt | VarStmt | AssignStmt | IfStmt | MatchStmt
               | LoopStmt | ForStmt | WhileStmt
               | BreakStmt | ContinueStmt | ReturnStmt | ExprStmt
               | UnsafeBlock ;

LetStmt        = "let" Pattern ( ":" Type )? "=" Expr ";" ;
VarStmt        = "var" Ident ( ":" Type )? "=" Expr ";" ;
AssignStmt     = LValue AssignOp Expr ";" ;
AssignOp       = "=" | "+=" | "-=" | "*=" | "/=" | "%=" ;
LValue         = Ident { "." Ident | "[" Expr "]" } ;

IfStmt         = "if" Expr Block ( "else" (IfStmt | Block) )? ;
MatchStmt      = "match" Expr "{" { MatchArm } "}" ;
MatchArm       = Pattern Guard? "=>" (Expr "," | Block) ;
Guard          = "if" Expr ;

LoopStmt       = ("'" Ident ":")? "loop" Block ;
ForStmt        = "for" Pattern "in" Expr Block ;
WhileStmt      = "while" Expr Block ;
BreakStmt      = "break" ("'" Ident)? Expr? ";" ;
ContinueStmt   = "continue" ("'" Ident)? ";" ;
ReturnStmt     = "return" Expr? ";" ;
ExprStmt       = Expr ";" ;

(* Expressions *)
Expr           = TryExpr | UnsafeExpr | SendExpr ;
TryExpr        = "try" Block ;
UnsafeExpr     = "unsafe" Block ;
SendExpr       = TimeoutExpr ( "<-" Expr )? ;
TimeoutExpr    = OrExpr ( "|" "after" Expr )? ;
OrExpr         = AndExpr { ("or" | "||") AndExpr } ;
AndExpr        = EqExpr  { ("and" | "&&") EqExpr } ;
EqExpr         = RelExpr { ("==" | "!=") RelExpr } ;
RelExpr        = RangeExpr { ("<" | "<=" | ">" | ">=") RangeExpr } ;
RangeExpr      = AddExpr ( (".." | "..=") AddExpr )? ;
AddExpr        = MulExpr { ("+" | "-") MulExpr } ;
MulExpr        = UnaryExpr { ("*" | "/" | "%") UnaryExpr } ;
UnaryExpr      = ("!" | "-" | "await") UnaryExpr | PostfixExpr ;
PostfixExpr    = Primary { "?" | "." Ident | "(" Args? ")" | "[" Expr "]" } ;

Primary        = Literal
               | InterpolatedStr
               | Ident ( "{" FieldInitList "}" )?
               | "[" ExprList? "]"
               | "[" Expr ";" Expr "]"
               | "(" Expr ")"
               | "(" ExprList ")"
               | IfExpr
               | MatchExpr
               | Lambda
               | Spawn
               | SelectExpr
               | RaceExpr
               | JoinExpr
               | ScopeSpawn
               | ScopeCancel
               | ScopeCheck
               | Scope
               | YieldExpr ;

FieldInitList  = FieldInit { "," FieldInit } ","? ;
FieldInit      = Ident ":" Expr ;

IfExpr         = "if" Expr Block ( "else" (IfExpr | Block) )? ;
MatchExpr      = "match" Expr "{" { MatchArm } "}" ;

Literal        = IntLit | FloatLit | StringLit | "true" | "false" ;
ExprList       = Expr { "," Expr } ;
Args           = Expr { "," Expr } ;

(* Closures *)
Lambda         = "move"? ( PipeLambda | ArrowLambda ) ;
PipeLambda     = "|" LambdaParams? "|" RetType? (Expr | Block) ;
ArrowLambda    = "(" LambdaParams? ")" "=>" (Expr | Block) ;
LambdaParams   = LambdaParam { "," LambdaParam } ;
LambdaParam    = Ident ( ":" Type )? ;

(* Actor operations *)
Spawn          = "spawn" ( LambdaActor | (Primary "(" Args? ")") ) ;
LambdaActor    = "move"? "(" LambdaParams? ")" RetType? "=>" (Expr | Block) ;

(* Concurrency expressions *)
SelectExpr     = "select" "{" SelectArm { SelectArm } "}" ;
SelectArm      = Ident "from" Expr "=>" Expr ","
               | "after" Expr "=>" Expr "," ;

RaceExpr       = "race" "{" (Expr ",")+ ("after" Expr "=>" Expr ",")? "}" ;

JoinExpr       = "join" "{" Expr { "," Expr } ","? "}" ;

(* Structured concurrency *)
Scope          = "scope" Block ;
ScopeSpawn     = "scope" "." "spawn" Block ;
ScopeCancel    = "scope" "." "cancel" "(" ")" ;
ScopeCheck     = "scope" "." ("is_cancelled" | "check_cancelled") "(" ")" ;
YieldExpr      = "yield" ;

(* Types *)
Type           = Ident TypeArgs?
               | "Task" "<" Type ">"
               | "Scope"
               | "ActorRef" "<" Type ">"
               | "Actor" "<" Type ("," Type)? ">"
               | "Arc" "<" Type ">"
               | "Rc" "<" Type ">"
               | "Weak" "<" Type ">"
               | "Result" "<" Type "," Type ">"
               | "Option" "<" Type ">"
               | "Vec" "<" Type ">"
               | "HashMap" "<" Type "," Type ">"
               | "(" TypeList? ")"
               | "[" Type ";" IntLit "]"
               | "[" Type "]"
               | "fn" "(" TypeList? ")" RetType?
               | "*" "const"? Type
               | "*" "mut" Type
               | "dyn" TraitBound
               | "dyn" "(" TraitBounds ")" ;

TypeArgs       = "<" Type { "," Type } ">" ;

(* Wire types *)
WireType       = "u8" | "u16" | "u32" | "u64"
               | "i8" | "i16" | "i32" | "i64"
               | "f32" | "f64"
               | "bool" | "bytes" | "string"
               | Ident | ("list" "[" WireType "]") ;

(* Pattern matching *)
Pattern        = "_"
               | LiteralPattern
               | Ident
               | Ident "(" PatternList? ")"
               | Ident "{" PatternFieldList? "}"
               | "(" PatternList ")"
               | Pattern "|" Pattern ;

LiteralPattern = IntLit | FloatLit | StringLit | "true" | "false" ;
PatternList    = Pattern { "," Pattern } ;
PatternFieldList = PatternField { "," PatternField } ;
PatternField   = Ident ( ":" Pattern )? ;

(* Literals *)
DurationLit    = IntLit ("ns" | "us" | "ms" | "s" | "m" | "h") ;
IntLit         = Digit { Digit | "_" }
               | "0x" HexDigit { HexDigit | "_" }
               | "0b" BinDigit { BinDigit | "_" } ;
FloatLit       = Digit { Digit } "." Digit { Digit }
                 ( ("e" | "E") ("+" | "-")? Digit { Digit } )? ;
StringLit      = '"' { Char | EscapeSeq } '"'
               | 'r"' { AnyChar } '"' ;
InterpolatedStr = 'f"' { Char | "{" Expr "}" } '"' ;

Ident          = Letter { Letter | Digit | "_" } ;
Letter         = "a".."z" | "A".."Z" ;
Digit          = "0".."9" ;
HexDigit       = Digit | "a".."f" | "A".."F" ;
BinDigit       = "0" | "1" ;
EscapeSeq      = "\\" ( "n" | "r" | "t" | "\\" | '"' | "0"
                        | "x" HexDigit HexDigit ) ;