{
module Presyntax.Parser where

import qualified Data.Text as T
import Data.Text (Text)

import Presyntax.Presyntax
import Presyntax.Tokens
import Presyntax.Lexer

}

%name parseExp Exp

%tokentype { Token }

%monad { Alex }
%lexer { lexer } { Token TokEof _ _ }

%errorhandlertype explist
%error { parseError }

%token
  var     { Token (TokVar $$) _ _ }
  '('     { Token TokOParen _ _ }
  ')'     { Token TokCParen _ _ }

  '{'     { Token TokOBrace _ _ }
  '}'     { Token TokCBrace _ _ }

  '\\'    { Token TokLambda _ _ }
  
  '->'    { Token TokArrow _ _ }
  ':'     { Token TokColon _ _ }
  '='     { Token TokEqual _ _ }

%%

Exp :: { Expr }
Exp
  : ExpFun Exp                       { App Ex $1 $2 }
  | ExpFun '{' Exp '}'               { App Im $1 $3 }
  | '\\' LambdaList '->' Exp         { makeLams $2 $4 }
  | '(' VarList ':' Exp ')' '->' Exp { makePis Ex $2 $4 $7 }
  | '{' VarList ':' Exp '}' '->' Exp { makePis Im $2 $4 $7 }
  | ExpFun '->' Exp                  { Pi Ex (T.singleton '_') $1 $3 }
  | ExpFun                           { $1 }

LambdaList :: { [(Plicity, Text)] }
  : var            { [(Ex, $1)] }
  | var LambdaList { (Ex, $1):$2 }

  | '{'var'}'            { [(Im, $2)] }
  | '{'var'}' LambdaList { (Im, $2):$4 }

VarList :: { [Text] }
  : var         { [$1] }
  | var VarList { $1:$2 }

ExpFun :: { Expr }
  : Atom        { $1 }
  | '(' Exp ')' { $2 }

Atom :: { Expr }
  : var { Var $1 }

{
lexer cont = alexMonadScan >>= cont

parseError x = alexError (show x)

makeLams xs b = foldr (uncurry Lam) b xs
makePis p xs t b = foldr (flip (Pi p) t) b xs
}