TypedBNF.lark

%mkrepl

%%
from _tbnf.src.apis import *
from tbnf.basic import mkpos
import json.decoder
def add(xs, x):
    xs.append(x)
    return xs

def unesc(x, f=json.decoder.py_scanstring):
    """from the raw form of a double quoted string to a python string,
    e.g.,
        unesc('"asd"') == "asd"
    """
    return f(x, 1)[0]
%%

start : list{toplevel} -> $1

### MACROS
empty{a} :   -> []
         | a -> $1

slist{sep, a} : a -> [$1]
              | slist{sep, a} sep a -> add($1, $3)

list{a} : a -> [$1]
        | list{a} a -> add($1, $2)

# empty or separated list
eslist{sep, a} : empty{slist{sep, a}} -> $1

# empty or list
elist{a} : empty{list{a}} -> $1

### Common

identstr : CNAMEPLUS -> str($1)

### Types

typ : arrow_typ -> $1

%%
def process_tparam(kvs):
    out = []
    for i, (k, v) in enumerate(kvs):
        if k == '_':
            out.append((f"value{i+1}", v))
        else:
            out.append((k, v))
    return out
%%
arrow_typ : typ2 "->" arrow_typ -> MK_TFun([("value", $1)], $3)
          | "(" eslist{",", param_type} ")" "->" arrow_typ -> MK_TFun(process_tparam($2), $5)
          | type_product -> MK_TTuple($1)

typ2 : CNAMEPLUS        -> MK_TConst(str($1))
     | tvar         -> $1
     | typ2 "<" slist{",", typ} ">" -> MK_TApp($1, $3)

type_product : type_product "*" typ2 -> add($1, $3)
             | typ2          -> [$1]

top_typ : "<" slist{",", tvar_str} ">" typ -> MK_Poly($2, $4)
        | typ                              -> MK_Mono($1)

tvar         : "'" CNAMEPLUS -> MK_TVar(str($2))
tvar_str     : "'" CNAMEPLUS -> str($2)
param_type   : CNAMEPLUS ":" typ -> (str($1), $3)
             | typ  -> ("_", $1)

### Toplevels

type_params : "<" slist{",", tvar_str} ">" -> $2
            | -> []

field_ann : CNAMEPLUS ":" typ -> (str($1), $3, mkpos($1))

field_anns : -> (False, [])  ## adt only
           | "(" eslist{",", field_ann} ")" -> (True, $2) ## record only

decl : "extern" "var" identstr ":" top_typ -> MK_Declvar($3, $5, mkpos($2))
     | "case" identstr ":" typ -> MK_Declctor($2, $4, mkpos($1))
     | "extern" "type" identstr type_params field_anns ->\
        MK_Decltype(True, $5[0], $3, $4, $5[1], mkpos($1))
     | "type" identstr type_params field_anns ->\
        MK_Decltype(False, $4[0], $2, $3, $4[1], mkpos($1))

toplevel :def             -> $1
        | decl            -> $1
        | lexerdef        -> $1
        | "ignore" slist{",", identstr}  -> MK_Defignore($2, mkpos($1))

def : CNAMEPLUS "(" slist{",", identstr} ")" productions ->\
        MK_Defmacro(str($1), $3, $5, mkpos($1))
    | CNAMEPLUS productions -> \
        MK_Defrule(str($1), $2, mkpos($1))

productions : ":" production -> [(mkpos($1), $2)]
            | productions "|" production -> add($1, (mkpos($2), $3))

production : elist{psym} "{" expr "}" -> MK_production($1, $3)

psym : "<" identstr ">" -> MK_Term(str($2), False)
     | ESCAPED_STRING   -> MK_Term(unesc(str($1)), True)
     | identstr         -> MK_Nonterm($1)
     | CNAMEPLUS "(" slist{",", psym} ")" -> MK_Macrocall(str($1), $3, mkpos($1))


### Simpler language

ann: identstr ":" typ        -> ($1, $3)

func_parameters : "(" eslist{",", ann} ")" -> $2

expr : "let" identstr "=" expr "in" expr -> \
            MK_expr(MK_ELet($2, $4, $6), mkpos($1))
     | "fun" func_parameters "->" expr -> \
            MK_expr(MK_EFun($2, $4), mkpos($1))
     | call -> $1
     | call ";" expr -> MK_expr(MK_ELet("_", $1, $3), $1.pos)

call : call "(" eslist{",", expr} ")" -> MK_expr(MK_EApp($1, $3), $1.pos)
     | atomexp -> $1

snd{a, b} : a b -> $2

atomexp : INT ->   MK_expr(MK_EInt(int($1)), mkpos($1))
        | FLOAT -> MK_expr(MK_EFlt(float($1)), mkpos($1))
        | ESCAPED_STRING -> MK_expr(MK_EStr(unesc($1)), mkpos($1))
        | "$" INT -> MK_expr(MK_ESlot(int($2)), mkpos($1))
        | "[" eslist{",", expr} "]" -> MK_expr(MK_EList($2), mkpos($1))
        | "(" ")" -> MK_expr(MK_ETuple([]), mkpos($1))
        | "(" slist{",", expr} ")" -> MK_expr(MK_ETuple($2), mkpos($1))
        | CNAMEPLUS -> MK_expr(MK_EVar(str($1)), mkpos($1))
        | atomexp "." CNAMEPLUS -> MK_expr(MK_EField($1, str($3)), $1.pos)
        | "true" -> MK_expr(MK_EBool(True), mkpos($1))
        | "false" -> MK_expr(MK_EBool(False), mkpos($1))

### Lexical definitions

%%
def u2i(ch):
    return int(ch[-4:], 16)

def to_unicode(ch):
    i = ord(ch)
    return i
    # return fr"\u{i:04X}"
%%

lexer :  slist{"|", lexer_and} -> MK_LOr($1)

lexer_and : list{lexer_atomexpr} -> MK_LSeq($1)

lexer_atomexpr :\
         lexer_atomexpr "+"            -> MK_LPlus($1)
      |  lexer_atomexpr "*"            -> MK_LStar($1)
      |  lexer_atomexpr "?"            -> MK_LOptional($1)
      |  lexer_atom -> $1

lexer_atom :  ESCAPED_STRING -> MK_LStr(unesc(str($1)))
      | "!" lexer_atom  -> MK_LNot($2)
      |  "(" lexer ")"  -> MK_LGroup($2)
      |  "\\d"          -> MK_LNumber
      | "[" UNICODE "-"  UNICODE "]" -> MK_LRange(u2i($2), u2i($4))
      | "[" /./ "-" /./ "]"          -> MK_LRange(ord($2), ord($4))
      | ("_" | ".") -> MK_LWildcard
      | CNAMEPLUS       -> MK_LRef(str($1))

lexerdef : CNAMEPLUS "=" lexer ";" -> MK_Deflexer(str($1), $3, mkpos($1))

UCODE : DIGIT | /[a-fA-F]/
UNICODE : "\\" "u" UCODE UCODE UCODE UCODE

LCASE_LETTER: "a".."z"
UCASE_LETTER: "A".."Z"

LETTER: UCASE_LETTER | LCASE_LETTER
WORD: LETTER+
CNAMEPLUS: ("_"|LETTER) ("_"|"-"|LETTER|DIGIT)*

%import common.ESCAPED_STRING
%import common.FLOAT
%import common.INT
%import common.WS
%import common.DIGIT
%import common.C_COMMENT
%import common.CPP_COMMENT
%ignore WS
%ignore C_COMMENT
%ignore CPP_COMMENT