-- File generated by the BNF Converter.
-- Parser definition for use with Happy.
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
{-# LANGUAGE PatternSynonyms #-}

module ParAlfa
  ( happyError
  , myLexer
  , pListDecl
  , pListDef
  , pDecl
  , pDef
  , pExp4
  , pExp3
  , pExp1
  , pExp
  , pExp2
  , pArrow
  , pTyping
  , pListTyping
  , pVarDecl
  , pBound
  , pListBound
  , pListVarDecl
  , pFieldDecl
  , pListFieldDecl
  , pBranch
  , pListBranch
  , pConstructor
  , pListConstructor
  , pIndConstructor
  , pListIndConstructor
  , pListExp2
  , pBinding
  , pListBinding
  , pPackageBody
  , pOpenArg
  , pDefAttr
  , pImport
  , pListDefAttr
  , pListAIdent
  , pListOpenArg
  , pAIdent
  ) where

import Prelude

import qualified AbsAlfa
import LexAlfa

}

%name pListDecl_internal ListDecl
%name pListDef_internal ListDef
%name pDecl_internal Decl
%name pDef_internal Def
%name pExp4_internal Exp4
%name pExp3_internal Exp3
%name pExp1_internal Exp1
%name pExp_internal Exp
%name pExp2_internal Exp2
%name pArrow_internal Arrow
%name pTyping_internal Typing
%name pListTyping_internal ListTyping
%name pVarDecl_internal VarDecl
%name pBound_internal Bound
%name pListBound_internal ListBound
%name pListVarDecl_internal ListVarDecl
%name pFieldDecl_internal FieldDecl
%name pListFieldDecl_internal ListFieldDecl
%name pBranch_internal Branch
%name pListBranch_internal ListBranch
%name pConstructor_internal Constructor
%name pListConstructor_internal ListConstructor
%name pIndConstructor_internal IndConstructor
%name pListIndConstructor_internal ListIndConstructor
%name pListExp2_internal ListExp2
%name pBinding_internal Binding
%name pListBinding_internal ListBinding
%name pPackageBody_internal PackageBody
%name pOpenArg_internal OpenArg
%name pDefAttr_internal DefAttr
%name pImport_internal Import
%name pListDefAttr_internal ListDefAttr
%name pListAIdent_internal ListAIdent
%name pListOpenArg_internal ListOpenArg
%name pAIdent_internal AIdent
%monad { Err } { (>>=) } { return }
%tokentype {Token}

%token
  '#' { PT _ (TS _ 1) }
  '(' { PT _ (TS _ 2) }
  ')' { PT _ (TS _ 3) }
  ',' { PT _ (TS _ 4) }
  '->' { PT _ (TS _ 5) }
  '.' { PT _ (TS _ 6) }
  '::' { PT _ (TS _ 7) }
  ';' { PT _ (TS _ 8) }
  '=' { PT _ (TS _ 9) }
  '?' { PT _ (TS _ 10) }
  '@_' { PT _ (TS _ 11) }
  'Set' { PT _ (TS _ 12) }
  'Type' { PT _ (TS _ 13) }
  '\\' { PT _ (TS _ 14) }
  '_' { PT _ (TS _ 15) }
  'abstract' { PT _ (TS _ 16) }
  'case' { PT _ (TS _ 17) }
  'concrete' { PT _ (TS _ 18) }
  'data' { PT _ (TS _ 19) }
  'idata' { PT _ (TS _ 20) }
  'import' { PT _ (TS _ 21) }
  'in' { PT _ (TS _ 22) }
  'let' { PT _ (TS _ 23) }
  'mutual' { PT _ (TS _ 24) }
  'of' { PT _ (TS _ 25) }
  'open' { PT _ (TS _ 26) }
  'package' { PT _ (TS _ 27) }
  'postulate' { PT _ (TS _ 28) }
  'private' { PT _ (TS _ 29) }
  'public' { PT _ (TS _ 30) }
  'sig' { PT _ (TS _ 31) }
  'struct' { PT _ (TS _ 32) }
  'type' { PT _ (TS _ 33) }
  'use' { PT _ (TS _ 34) }
  'where' { PT _ (TS _ 35) }
  '{' { PT _ (TS _ 36) }
  '|' { PT _ (TS _ 37) }
  '|->' { PT _ (TS _ 38) }
  '}' { PT _ (TS _ 39) }
  L_charac { PT _ (TC _)}
  L_doubl { PT _ (TD _)}
  L_integ { PT _ (TI _)}
  L_quoted { PT _ (TL _)}
  L_Comment { PT _ (T_Comment _) }
  L_Infix { PT _ (T_Infix _) }
  L_PIdent { PT _ (T_PIdent _) }

%%

Char :: { (AbsAlfa.BNFC'Position, Char) }
Char  : L_charac { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), (read (tokenText $1) ) :: Char) }

Double :: { (AbsAlfa.BNFC'Position, Double) }
Double  : L_doubl  { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), (read (tokenText $1) ) :: Double) }

Integer :: { (AbsAlfa.BNFC'Position, Integer) }
Integer  : L_integ  { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), (read (tokenText $1) ) :: Integer) }

String :: { (AbsAlfa.BNFC'Position, String) }
String  : L_quoted { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), ((\(PT _ (TL s)) -> s) $1)) }

Comment :: { (AbsAlfa.BNFC'Position, AbsAlfa.Comment) }
Comment : L_Comment { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Comment (tokenText $1)) }

Infix :: { (AbsAlfa.BNFC'Position, AbsAlfa.Infix) }
Infix : L_Infix { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Infix (tokenText $1)) }

PIdent :: { (AbsAlfa.BNFC'Position, AbsAlfa.PIdent) }
PIdent : L_PIdent { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.PIdent (mkPosToken $1)) }

ListDecl :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Decl]) }
ListDecl
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | Decl { (fst $1, (:[]) (snd $1)) }
  | Decl ';' ListDecl { (fst $1, (:) (snd $1) (snd $3)) }

ListDef :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Def]) }
ListDef
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | Def { (fst $1, (:[]) (snd $1)) }
  | Def ';' ListDef { (fst $1, (:) (snd $1) (snd $3)) }

Decl :: { (AbsAlfa.BNFC'Position, AbsAlfa.Decl) }
Decl
  : Import { (fst $1, AbsAlfa.DImp (fst $1) (snd $1)) }
  | ListDefAttr Def { (fst $1, AbsAlfa.DDef (fst $1) (snd $1) (snd $2)) }

Def :: { (AbsAlfa.BNFC'Position, AbsAlfa.Def) }
Def
  : 'data' AIdent ListTyping '=' ListConstructor { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Data (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $5)) }
  | 'mutual' '{' ListDef '}' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Mutual (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $3)) }
  | 'open' Exp 'use' ListOpenArg { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Open (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $4)) }
  | 'package' AIdent ListTyping 'where' PackageBody { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Package (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $5)) }
  | 'postulate' AIdent ListTyping '::' Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Axiom (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $5)) }
  | 'type' AIdent ListTyping '=' Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Type (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $5)) }
  | Comment { (fst $1, AbsAlfa.Commt (fst $1) (snd $1)) }
  | AIdent '=' Exp { (fst $1, AbsAlfa.Binding (fst $1) (snd $1) (snd $3)) }
  | AIdent ListVarDecl '::' Exp '=' Exp { (fst $1, AbsAlfa.Value (fst $1) (snd $1) (snd $2) (snd $4) (snd $6)) }

Exp4 :: { (AbsAlfa.BNFC'Position, AbsAlfa.Exp) }
Exp4
  : '#' Integer { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EStar (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | '(' Exp ')' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), (snd $2)) }
  | '?' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EMeta (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | 'Set' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.ESet (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | 'Type' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EType (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | '_' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EMetaU (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | Char { (fst $1, AbsAlfa.EChar (fst $1) (snd $1)) }
  | Double { (fst $1, AbsAlfa.EDouble (fst $1) (snd $1)) }
  | Integer { (fst $1, AbsAlfa.EInt (fst $1) (snd $1)) }
  | String { (fst $1, AbsAlfa.EString (fst $1) (snd $1)) }
  | AIdent { (fst $1, AbsAlfa.EVar (fst $1) (snd $1)) }
  | AIdent '@_' { (fst $1, AbsAlfa.ECon (fst $1) (snd $1)) }

Exp3 :: { (AbsAlfa.BNFC'Position, AbsAlfa.Exp) }
Exp3
  : Exp3 '.' AIdent { (fst $1, AbsAlfa.EProj (fst $1) (snd $1) (snd $3)) }
  | Exp4 { (fst $1, (snd $1)) }

Exp1 :: { (AbsAlfa.BNFC'Position, AbsAlfa.Exp) }
Exp1
  : 'sig' '{' ListFieldDecl '}' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.ESig (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $3)) }
  | 'struct' '{' ListBinding '}' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EStr (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $3)) }
  | Exp1 Exp2 { (fst $1, AbsAlfa.EApp (fst $1) (snd $1) (snd $2)) }
  | Exp2 { (fst $1, (snd $1)) }

Exp :: { (AbsAlfa.BNFC'Position, AbsAlfa.Exp) }
Exp
  : '\\' VarDecl Arrow Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EAbs (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $4)) }
  | '\\' ListAIdent Arrow Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EAbsUnt (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $4)) }
  | 'case' Exp 'of' '{' ListBranch '}' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.ECase (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $5)) }
  | 'data' ListConstructor { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.ESum (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | 'idata' ListVarDecl ListIndConstructor { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EIData (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3)) }
  | 'let' '{' ListDecl '}' 'in' Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.ELet (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $3) (snd $6)) }
  | 'open' Exp 'use' ListOpenArg 'in' Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.EOpen (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $4) (snd $6)) }
  | Comment Exp1 { (fst $1, AbsAlfa.ECommL (fst $1) (snd $1) (snd $2)) }
  | VarDecl Arrow Exp { (fst $1, AbsAlfa.EPi (fst $1) (snd $1) (snd $2) (snd $3)) }
  | Exp1 { (fst $1, (snd $1)) }
  | Exp1 Comment { (fst $1, AbsAlfa.ECommR (fst $1) (snd $1) (snd $2)) }
  | Exp1 Infix Exp1 { (fst $1, AbsAlfa.EInfix (fst $1) (snd $1) (snd $2) (snd $3)) }
  | Exp1 Arrow Exp { (fst $1, AbsAlfa.EFun (fst $1) (snd $1) (snd $2) (snd $3)) }

Exp2 :: { (AbsAlfa.BNFC'Position, AbsAlfa.Exp) }
Exp2
  : Exp3 { (fst $1, (snd $1)) }

Arrow :: { (AbsAlfa.BNFC'Position, AbsAlfa.Arrow) }
Arrow
  : '->' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.AShow (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | '|->' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.AHide (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }

Typing :: { (AbsAlfa.BNFC'Position, AbsAlfa.Typing) }
Typing
  : VarDecl { (fst $1, AbsAlfa.TDecl (fst $1) (snd $1)) }
  | Exp2 { (fst $1, AbsAlfa.TExp (fst $1) (snd $1)) }

ListTyping :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Typing]) }
ListTyping
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | Typing ListTyping { (fst $1, (:) (snd $1) (snd $2)) }

VarDecl :: { (AbsAlfa.BNFC'Position, AbsAlfa.VarDecl) }
VarDecl
  : '(' ListBound '::' Exp ')' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.VDecl (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $4)) }

Bound :: { (AbsAlfa.BNFC'Position, AbsAlfa.Bound) }
Bound
  : '|' AIdent { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.BHide (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | AIdent { (fst $1, AbsAlfa.BVar (fst $1) (snd $1)) }

ListBound :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Bound]) }
ListBound
  : Bound { (fst $1, (:[]) (snd $1)) }
  | Bound ',' ListBound { (fst $1, (:) (snd $1) (snd $3)) }

ListVarDecl :: { (AbsAlfa.BNFC'Position, [AbsAlfa.VarDecl]) }
ListVarDecl
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | VarDecl ListVarDecl { (fst $1, (:) (snd $1) (snd $2)) }

FieldDecl :: { (AbsAlfa.BNFC'Position, AbsAlfa.FieldDecl) }
FieldDecl
  : AIdent '::' Exp { (fst $1, AbsAlfa.FDecl (fst $1) (snd $1) (snd $3)) }

ListFieldDecl :: { (AbsAlfa.BNFC'Position, [AbsAlfa.FieldDecl]) }
ListFieldDecl
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | FieldDecl { (fst $1, (:[]) (snd $1)) }
  | FieldDecl ';' ListFieldDecl { (fst $1, (:) (snd $1) (snd $3)) }

Branch :: { (AbsAlfa.BNFC'Position, AbsAlfa.Branch) }
Branch
  : '(' AIdent Infix AIdent ')' '->' Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.BranchInf (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $4) (snd $7)) }
  | '(' AIdent ListAIdent ')' '->' Exp { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.BranchCon (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $3) (snd $6)) }
  | AIdent '->' Exp { (fst $1, AbsAlfa.BranchVar (fst $1) (snd $1) (snd $3)) }

ListBranch :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Branch]) }
ListBranch
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | Branch { (fst $1, (:[]) (snd $1)) }
  | Branch ';' ListBranch { (fst $1, (:) (snd $1) (snd $3)) }

Constructor :: { (AbsAlfa.BNFC'Position, AbsAlfa.Constructor) }
Constructor
  : AIdent ListTyping { (fst $1, AbsAlfa.Cnstr (fst $1) (snd $1) (snd $2)) }

ListConstructor :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Constructor]) }
ListConstructor
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | Constructor { (fst $1, (:[]) (snd $1)) }
  | Constructor '|' ListConstructor { (fst $1, (:) (snd $1) (snd $3)) }

IndConstructor :: { (AbsAlfa.BNFC'Position, AbsAlfa.IndConstructor) }
IndConstructor
  : AIdent ListTyping '::' '_' ListExp2 { (fst $1, AbsAlfa.ICnstr (fst $1) (snd $1) (snd $2) (snd $5)) }

ListIndConstructor :: { (AbsAlfa.BNFC'Position, [AbsAlfa.IndConstructor]) }
ListIndConstructor
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | IndConstructor { (fst $1, (:[]) (snd $1)) }
  | IndConstructor '|' ListIndConstructor { (fst $1, (:) (snd $1) (snd $3)) }

ListExp2 :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Exp]) }
ListExp2
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | Exp2 ListExp2 { (fst $1, (:) (snd $1) (snd $2)) }

Binding :: { (AbsAlfa.BNFC'Position, AbsAlfa.Binding) }
Binding
  : AIdent '=' Exp { (fst $1, AbsAlfa.Bind (fst $1) (snd $1) (snd $3)) }

ListBinding :: { (AbsAlfa.BNFC'Position, [AbsAlfa.Binding]) }
ListBinding
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | Binding { (fst $1, (:[]) (snd $1)) }
  | Binding ';' ListBinding { (fst $1, (:) (snd $1) (snd $3)) }

PackageBody :: { (AbsAlfa.BNFC'Position, AbsAlfa.PackageBody) }
PackageBody
  : '{' ListDecl '}' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.PackageDef (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | Exp { (fst $1, AbsAlfa.PackageInst (fst $1) (snd $1)) }

OpenArg :: { (AbsAlfa.BNFC'Position, AbsAlfa.OpenArg) }
OpenArg
  : ListDefAttr AIdent { (fst $1, AbsAlfa.OArg (fst $1) (snd $1) (snd $2)) }
  | ListDefAttr AIdent '::' Exp { (fst $1, AbsAlfa.OArgT (fst $1) (snd $1) (snd $2) (snd $4)) }
  | ListDefAttr AIdent '::' Exp '=' Exp { (fst $1, AbsAlfa.OArgTD (fst $1) (snd $1) (snd $2) (snd $4) (snd $6)) }
  | ListDefAttr AIdent '=' Exp { (fst $1, AbsAlfa.OArgD (fst $1) (snd $1) (snd $2) (snd $4)) }

DefAttr :: { (AbsAlfa.BNFC'Position, AbsAlfa.DefAttr) }
DefAttr
  : 'abstract' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Abstract (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | 'concrete' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Concrete (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | 'private' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Private (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }
  | 'public' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Public (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1))) }

Import :: { (AbsAlfa.BNFC'Position, AbsAlfa.Import) }
Import
  : 'import' String ';' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.Import (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2)) }

ListDefAttr :: { (AbsAlfa.BNFC'Position, [AbsAlfa.DefAttr]) }
ListDefAttr
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | DefAttr ListDefAttr { (fst $1, (:) (snd $1) (snd $2)) }

ListAIdent :: { (AbsAlfa.BNFC'Position, [AbsAlfa.AIdent]) }
ListAIdent
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | AIdent ListAIdent { (fst $1, (:) (snd $1) (snd $2)) }

ListOpenArg :: { (AbsAlfa.BNFC'Position, [AbsAlfa.OpenArg]) }
ListOpenArg
  : {- empty -} { (AbsAlfa.BNFC'NoPosition, []) }
  | OpenArg { (fst $1, (:[]) (snd $1)) }
  | OpenArg ',' ListOpenArg { (fst $1, (:) (snd $1) (snd $3)) }

AIdent :: { (AbsAlfa.BNFC'Position, AbsAlfa.AIdent) }
AIdent
  : '(' Infix ')' { (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1), AbsAlfa.I (uncurry AbsAlfa.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | PIdent { (fst $1, AbsAlfa.F (fst $1) (snd $1)) }

{

type Err = Either String

happyError :: [Token] -> Err a
happyError ts = Left $
  "syntax error at " ++ tokenPos ts ++ 
  case ts of
    []      -> []
    [Err _] -> " due to lexer error"
    t:_     -> " before `" ++ (prToken t) ++ "'"

myLexer :: String -> [Token]
myLexer = tokens

-- Entrypoints

pListDecl :: [Token] -> Err [AbsAlfa.Decl]
pListDecl = fmap snd . pListDecl_internal

pListDef :: [Token] -> Err [AbsAlfa.Def]
pListDef = fmap snd . pListDef_internal

pDecl :: [Token] -> Err AbsAlfa.Decl
pDecl = fmap snd . pDecl_internal

pDef :: [Token] -> Err AbsAlfa.Def
pDef = fmap snd . pDef_internal

pExp4 :: [Token] -> Err AbsAlfa.Exp
pExp4 = fmap snd . pExp4_internal

pExp3 :: [Token] -> Err AbsAlfa.Exp
pExp3 = fmap snd . pExp3_internal

pExp1 :: [Token] -> Err AbsAlfa.Exp
pExp1 = fmap snd . pExp1_internal

pExp :: [Token] -> Err AbsAlfa.Exp
pExp = fmap snd . pExp_internal

pExp2 :: [Token] -> Err AbsAlfa.Exp
pExp2 = fmap snd . pExp2_internal

pArrow :: [Token] -> Err AbsAlfa.Arrow
pArrow = fmap snd . pArrow_internal

pTyping :: [Token] -> Err AbsAlfa.Typing
pTyping = fmap snd . pTyping_internal

pListTyping :: [Token] -> Err [AbsAlfa.Typing]
pListTyping = fmap snd . pListTyping_internal

pVarDecl :: [Token] -> Err AbsAlfa.VarDecl
pVarDecl = fmap snd . pVarDecl_internal

pBound :: [Token] -> Err AbsAlfa.Bound
pBound = fmap snd . pBound_internal

pListBound :: [Token] -> Err [AbsAlfa.Bound]
pListBound = fmap snd . pListBound_internal

pListVarDecl :: [Token] -> Err [AbsAlfa.VarDecl]
pListVarDecl = fmap snd . pListVarDecl_internal

pFieldDecl :: [Token] -> Err AbsAlfa.FieldDecl
pFieldDecl = fmap snd . pFieldDecl_internal

pListFieldDecl :: [Token] -> Err [AbsAlfa.FieldDecl]
pListFieldDecl = fmap snd . pListFieldDecl_internal

pBranch :: [Token] -> Err AbsAlfa.Branch
pBranch = fmap snd . pBranch_internal

pListBranch :: [Token] -> Err [AbsAlfa.Branch]
pListBranch = fmap snd . pListBranch_internal

pConstructor :: [Token] -> Err AbsAlfa.Constructor
pConstructor = fmap snd . pConstructor_internal

pListConstructor :: [Token] -> Err [AbsAlfa.Constructor]
pListConstructor = fmap snd . pListConstructor_internal

pIndConstructor :: [Token] -> Err AbsAlfa.IndConstructor
pIndConstructor = fmap snd . pIndConstructor_internal

pListIndConstructor :: [Token] -> Err [AbsAlfa.IndConstructor]
pListIndConstructor = fmap snd . pListIndConstructor_internal

pListExp2 :: [Token] -> Err [AbsAlfa.Exp]
pListExp2 = fmap snd . pListExp2_internal

pBinding :: [Token] -> Err AbsAlfa.Binding
pBinding = fmap snd . pBinding_internal

pListBinding :: [Token] -> Err [AbsAlfa.Binding]
pListBinding = fmap snd . pListBinding_internal

pPackageBody :: [Token] -> Err AbsAlfa.PackageBody
pPackageBody = fmap snd . pPackageBody_internal

pOpenArg :: [Token] -> Err AbsAlfa.OpenArg
pOpenArg = fmap snd . pOpenArg_internal

pDefAttr :: [Token] -> Err AbsAlfa.DefAttr
pDefAttr = fmap snd . pDefAttr_internal

pImport :: [Token] -> Err AbsAlfa.Import
pImport = fmap snd . pImport_internal

pListDefAttr :: [Token] -> Err [AbsAlfa.DefAttr]
pListDefAttr = fmap snd . pListDefAttr_internal

pListAIdent :: [Token] -> Err [AbsAlfa.AIdent]
pListAIdent = fmap snd . pListAIdent_internal

pListOpenArg :: [Token] -> Err [AbsAlfa.OpenArg]
pListOpenArg = fmap snd . pListOpenArg_internal

pAIdent :: [Token] -> Err AbsAlfa.AIdent
pAIdent = fmap snd . pAIdent_internal
}