{
module Presyntax.Lexer where

import qualified Data.ByteString.Lazy as Lbs
import qualified Data.Text.Encoding as T

import Presyntax.Tokens
}

%wrapper "monad-bytestring"

$alpha = [a-zA-Z]
$digit = [0-9]

tokens :-
  $white+                      ;
  $alpha [$alpha $digit \_ \']* { yield TokVar }
  
  \=                            { always TokEqual }
  \:                            { always TokColon }
  \,                            { always TokComma }
  \*                            { always TokStar }

  ".1"                          { always TokPi1 }
  ".2"                          { always TokPi2 }
  
  \\                            { always TokLambda }
  "->"                          { always TokArrow }

  \(                            { always TokOParen }
  \{                            { always TokOBrace }

  \)                            { always TokCParen }
  \}                            { always TokCBrace }

{
alexEOF :: Alex Token
alexEOF = do
  (AlexPn _ l c, _, _, _) <- alexGetInput
  pure $ Token TokEof l c

yield k (AlexPn _ l c, _, s, _) i = pure (Token (k $! (T.decodeUtf8 (Lbs.toStrict (Lbs.take i s)))) l c)
always k x i = yield (const k) x i
}