syntaxes.ebnf

(* =========================================
   File & Top-level
   ========================================= *)
SourceFile = TopItem*

TopItem = Annotation* Visibility? (
    | UseDecl
    | FunDecl | ConstFunDecl | ConstDecl | GlobalDecl
    | TypeDecl | AbstractDecl | EffectDecl
    | ExternalDecl
)

Visibility = "pub" | "pub" "(" "external" ")"

Annotation = "#" Ident ( "(" (Expr ("," Expr)*)? ")" )? NewLine

(* =========================================
   Import / Use
   ========================================= *)
UseDecl = "use" "@"? Ident ("." Ident)* ("only" Ident ("," Ident)*)? "*"? NewLine

(* =========================================
   Declarations
   ========================================= *)
ConstDecl   = "const" Ident (":" Type)? "=" Expr NewLine
GlobalDecl  = "global" Ident (":" Type)? "=" Expr NewLine

FunDecl     = "fun" Ident GenericParams? "(" Param ("," Param)* ")" ("->" Type)? EffectRow? Where? ";"
ConstFunDecl= "const" FunDecl
FunDef      = "fun" Ident GenericParams? "(" Param ("," Param)* ")" ("->" Type)? EffectRow? Where?
              Indent Expr* Dedent

Param       = Ident (":" Type)?

GenericParams = "[" GenericVar ("," GenericVar)* "]"
GenericVar    = Ident

(* --- Type declarations --- *)
TypeDecl   = "type" Ident GenericParams? ImplList? ";"                      (* opaque *)
TypeAlias  = "type" Ident GenericParams? ImplList? "=" Type Where? NewLine  (* alias *)
TypeStruct = "type" Ident GenericParams? ImplList? Where?
             Indent Field* Dedent                                           (* struct *)
AdtDecl    = "type" Ident GenericParams? ImplList? Where?
             Indent ("|" Ctor)* Dedent                                      (* ADT *)

ImplList   = "impl" Ident ("+" Ident)*
Field      = Ident ":" Type NewLine
Ctor       = Ident GenericParams? ("of" Type ("->" Type)?)? NewLine

(* --- Abstract type (trait-like) --- *)
AbstractDecl = "abst" Ident GenericParams? ImplList? NewLine Where?
               Indent MethodDecl* Dedent
MethodDecl   = "fun" Ident "(" Param ("," Param)* ")" ("->" Type)? EffectRow? ";" NewLine

(* --- Effect --- *)
EffectDecl   = "effect" Ident NewLine
               Indent ("|" EffectControl NewLine)* Dedent
EffectControl= Ident ("(" Param ("," Param)* ")")? ("->" Type)?

(* --- External --- *)
ExternalDecl = "external" "fun" Ident "(" Param ("," Param)* ("...")? ")" ("->" Type)? ("=" String)? ";" NewLine
CTypeDecl    = "external" "ctype" Ident ";"

(* =========================================
   Types
   ========================================= *)
Type = RefType | MutRefType | ShareType | ImplType
     | TypeofType | WildcardType | TupleType | FunType | NamedType

RefType      = "ref" Type
MutRefType   = "ref" "mut" Type
ShareType    = "share" Type
ImplType     = "impl" Type
TypeofType   = "typeof" "(" Expr ")"
WildcardType = "_"
TupleType    = "(" TupleElement ("," TupleElement)* ")"
TupleElement = Type ("*" Int)?
FunType      = "fun" "(" Type ("," Type)* ")" "->" Type EffectRow?
NamedType    = Path ("[" Type ("," Type)* "]")?

(* Effect-row annotation:
     fun f()                pure (no raise): closed empty row
     fun f() raise          inferred open row
     fun f() raise Foo+Bar          definite {Foo, Bar}, closed
     fun f() raise Foo | Bar        definite {Foo}, possible {Bar}, closed
     fun f() raise Foo | ^r         definite {Foo}, open named tail r
     fun f() raise Foo | ...        definite {Foo}, anonymous open tail
     fun f() raise ...              fully polymorphic open row
   Legacy: `raise Foo+...` == `raise Foo | ...`. *)
EffectRow    = "raise" (EffectBody)?
EffectBody   = "..." | EffectSum ("|" EffectTail)?
EffectSum    = EffectAtom ("+" EffectAtom)*
EffectAtom   = Path
EffectTail   = "^" Ident | "..." | EffectSum

Where        = "where" WhereConstraint ("," WhereConstraint)*
WhereConstraint = Ident ":" Type ("+" Type)*

(* =========================================
   Expressions (Pratt parser, BP-based)
   ========================================= *)
(* Dispatcher first tries keyword forms, then falls to parse_expr_bp(0) *)

Expr = IfExpr | DoExpr | LetExpr | ReturnExpr | MatchExpr
     | RaiseExpr | WithExpr | ResumeExpr | ConstEvalExpr
     | UnsafeExternalCallExpr
     | parse_expr_bp(0)  (* Pratt core *)

(* Binding powers (higher = tighter):
   60 : ^
   50 : * / %
   40 : + -
   30 : == != < > <= >=   (and `is`)
   20 : &&                (and `as`)
   10 : ||
    1 : |>  (Pipeline, left-assoc)  <|  (Reverse Pipe, right-assoc)
   70 : prefix - ! , prefix custom UserOp
*)

(* Prefix (NUD) *)
PrefixExpr = ("-" | "!") PrefixExpr                             (* UnaryExpr, rbp=70 *)
           | UserOp PrefixExpr                                  (* custom prefix *)
           | ("move" | "copy" | "share") Expr                   (* rbp=60 *)
           | "ref" ["mut"] Expr                                 (* rbp=60 *)
           | Path                                               (* StaticPathExpr *)
           | ParenExpr | AtomExpr

AtomExpr   = Int | Float | String | "..."

ParenExpr  = "(" ")"                                             (* empty tuple, AtomExpr *)
           | "(" Expr ("," Expr)* ")"                            (* tuple, AtomExpr *)
           | "(" Expr ")"                                        (* grouping *)

(* Infix (LED) + postfix ops *)
ExprBP = ExprBP BinaryOp ExprBP                                  (* BinaryExpr *)
       | ExprBP "|>" ExprBP                                      (* PipeLineExpr, left-assoc *)
       | ExprBP "<|" ExprBP                                      (* PipeBackExpr, right-assoc *)
       | ExprBP UserOp{postfix}                                  (* UnaryExpr, no RHS *)
       | ExprBP "(" CallArg ("," CallArg)* ")"                   (* CallExpr *)
       | ExprBP "is" Pattern                                     (* IsExpr, bp=30 *)
       | ExprBP "as" Type                                        (* TypeCastExpr, bp=20 *)
       | ExprBP "." Ident                                        (* MemberAccessExpr *)
       | ExprBP "." Int                                          (* TupleIndexExpr *)
       | ExprBP "{" StructFieldInit ("," StructFieldInit)* "}"   (* MakeStructExpr *)

CallArg          = (Ident "=")? Expr
StructFieldInit  = Ident "=" Expr

(* Keyword expressions *)
DoExpr    = "do" NewLine Indent Expr* Dedent
LetExpr   = "let" ["mut"] Ident (":" Type)? "=" Expr
ReturnExpr= "return" Expr?
IfExpr    = "if" Expr ("then" Expr | NewLine BlockExpr)
            ("elif" Expr NewLine BlockExpr)*
            ("else" (NewLine BlockExpr | Expr))?
MatchExpr = "when" Expr NewLine Indent MatchArm* Dedent
MatchArm  = Pattern ("if" Expr)? "=>" Expr NewLine

RaiseExpr = "raise" Path (" Expr ("," Expr)* ")"
WithExpr  = "with" Expr ("catch" Path "(" CatchParam ("," CatchParam)* ")" NewLine BlockExpr)*
CatchParam= ".." | "binding" Ident

ResumeExpr       = "resume" Expr
ConstEvalExpr    = "const" "(" Expr ")"
UnsafeExternalCallExpr = "unsafe_call_external" Path "(" Expr ("," Expr)* ")"

(* =========================================
   Patterns
   ========================================= *)
Pattern         = PatternUnit ("|" PatternUnit)*                  (* OrPat *)
PatternUnit     = SinglePattern ("binding" Ident)?                (* AliasPat *)
SinglePattern   = AtomicPattern | (SinglePattern "binding" Ident)

AtomicPattern =
    | "_"                                                         (* WildcardPat *)
    | "binding" Ident                                             (* BindingPat *)
    | ".."                                                        (* RestPat *)
    | Int | Float | String                                        (* LiteralPat *)
    | "(" PatternItem ("," PatternItem)* ")"                      (* TuplePat *)
    | Ident "(" PatternItem ("," PatternItem)* ")"                (* ConstructorPat *)
    | Ident "{" StructPatField ("," StructPatField)* ".."? "}"    (* StructPat *)
    | Ident                                                       (* plain BindingPat *)

PatternItem     = Pattern | ".."
StructPatField  = Ident                                          (* sugar: x = binding x *)

(* Shared helpers *)
Path  = Ident ("." Ident)*
BlockExpr = Indent Expr* Dedent