// Start ::= 'module' ModuleID (Export)* 'where' Block
(diagram start
	(sequence
	  (terminal "module")
	  (nonterminal ModuleID)
	  (optional
	    (nonterminal Exports))
	  (terminal "where")
	  (nonterminal Block)))

// ModuleID ::= Identifier
(diagram ModuleID
	(sequence
	  (nonterminal ModuleIdentifier)))

// Exports ::= Export ("," Export)*
(diagram Exports
	(sequence
	  (terminal "(")
	  (loop
	    (nonterminal Export)
	    (terminal ","))
	  (terminal ")")))

// Export ::= QFunctionName | QTypeConstrID | QTypeConstrID (..) 
// | 'module' ModuleID
(diagram Export
	(sequence
	  (choice
	    (nonterminal QFunctionName)
	    (nonterminal QTypeConstrID)
	    (sequence
	      (nonterminal QTypeConstrID)
	      (terminal "(..)"))
	    (sequence
	      (terminal "module")
	      (nonterminal ModuleID)))))
	
// QFunctionName ::= '(' QInfixOpID ')' | QFunctionID
(diagram QFunctionName
	(sequence
	  (choice
	    (sequence
	      (terminal "(")
	      (nonterminal QInfixOpID)
	      (terminal ")"))
	    (nonterminal QFunctionID))))

// QTypeConstrID ::= (ModuleID '.')? Identifier
(diagram QTypeConstrID
	(sequence
	  (optional
	    (sequence
	      (nonterminal ModuleID)
	      (terminal ".")))
	  (nonterminal TypeConstrID)))

// TypeConstrID ::= (Identifier)+
(diagram TypeConstrID
	(sequence
	  (nonterminal Identifier)))

// QInfixOpID ::= (ModuleID '.')? InfixOpID
(diagram QInfixOpID
	(sequence
	  (optional
	    (sequence
	      (nonterminal ModuleID)
	      (terminal ".")))
	  (nonterminal InfixOpID)))
	 

// QFunctionID ::= (ModuleID '.')? FunctionID
(diagram QFunctionID
	(sequence
	  (optional
	    (sequence
	      (nonterminal ModuleID)
	      (terminal ".")))
	  (nonterminal FunctionID)))

// FunctionID ::= (Identifier)+
(diagram FunctionID
	(sequence
	  (nonterminal Identifier)))

(diagram Block
	(sequence
	  (optional
	    (nonterminal ImportDecls))
	  (optional
	    (nonterminal PragmaDecls))
	  (optional
	    (nonterminal FixityDecls))
	  (optional
	    (nonterminal BlockDecls))
	  (terminal EOF)))	

// ImportDecls ::= ImportDeclaration (";" ImportDeclaration
(diagram ImportDecls
	(sequence
	  (sequence
	      (loop
		(nonterminal ImportDeclaration)
		(terminal ";")))))

// PragmaDecls ::= PragmaDeclaration (";" PragmaDeclaration)*
(diagram PragmaDecls
	(sequence
	  (loop
	    (nonterminal PragmaDeclaration)
	    (terminal ";"))))

// FixityDecls ::= FixityDeclaration (";" FixityDeclaration)*
(diagram FixityDecls
	(sequence
	  (loop
	    (nonterminal FixityDeclaration)
  	    (terminal ";"))))

// BlockDecls ::= BlockDeclaration (";" BlockDeclaration)*
(diagram BlockDecls
	(sequence
	  (loop
	    (nonterminal BlockDeclaration)
  	    (terminal ";"))))

//ImportDeclaration ::= "import" ("qualified")? ModuleID ("as" ModuleID)?
//		(ImportRestr)?
(diagram ImportDeclaration
	(sequence
	  (terminal "import")
	  (optional
	    (sequence
	      (terminal "qualified")))
	  (nonterminal ModuleID)
	  (optional
	    (sequence
	      (terminal "as")
	      (nonterminal ModuleID)))
	  (optional
	    (sequence
	      (nonterminal ImportRestr)))))

//ImportRestr ::= (Import)+ | "hiding" (Import)+
(diagram ImportRestr
	(sequence
	  (choice
	    (sequence
	      (terminal "(")
	      (loop
	        (nonterminal Import)
	        (terminal ","))
	      (terminal ")"))
	    (sequence
	      (terminal "hiding")
	      (terminal "(")
	      (loop
                (nonterminal Import)
		(terminal ","))
	      (terminal ")")))))

// Import ::= FunctionName | TypeConstrID | TypeConstrID "(..)"
(diagram Import
	(sequence
	  (choice
	    (nonterminal FunctionName)
	    (nonterminal TypeConstrID)
	    (sequence
	      (nonterminal TypeConstrID)
	      (terminal "(..)")))))

// FunctionName ::= "(" InfixOpID ")" | FunctionID
(diagram FunctionName
	(sequence
	  (choice
	    (sequence
	      (terminal "(")
	      (nonterminal InfixOpID)
	      (terminal ")"))
	    (nonterminal FunctionID))))

//PragmaDeclaration ::= ( "pragma" ( "flex" | "rigid" ) )

(diagram PragmaDeclaration
	(sequence
	  (terminal "pragma")
	  (choice
	    (terminal "flex")
	    (terminal "rigid"))))

//FixityDeclarationList ::= ( FixityDeclaration )

(diagram FixityDeclarationList
	(sequence
	  (nonterminal FixityDeclaration)))

//DataOrFunctionDeclarationList ::=
//	( ( DataDeclaration | FunctionDeclaration ) )

(diagram BlockDeclaration
	(sequence
	  (choice
	    (nonterminal TypeSynonymDeclaration)
	    (nonterminal DataDeclaration)
	    (nonterminal FunctionDeclaration))))

//FixityDeclaration ::= FixityKeyWord Integer ( Infixed ( "," Infixed )* )

(diagram FixityDeclaration
        (sequence
	  (nonterminal FixityKeyWord)
          (nonterminal Integer)
	  (loop
	    (nonterminal Infixed)
            (terminal ","))))

//FixityKeyWord ::= ( "infix" | "infixr" | "infixl" )

(diagram FixityKeyWord
	(sequence
	  (choice
	    (terminal "infix")
	    (terminal "infixr")
	    (terminal "infixl"))))

//TypeSynonymDeclaration ::= "type" TypeConstrID (TypeVarID)+ "=" TypeExpr
(diagram TypeSynonymDeclaration
	(sequence
	  (terminal "type")
	  (nonterminal TypeConstrID)
	  (one-or-more (nonterminal TypeVarID))
	  (terminal "=")
	  (nonterminal TypeExpr)))
	  
//TypeVarID ::= Identifier
(diagram TypeVarID
	(sequence
	  (nonterminal Identifier)))

//TypeExpr ::= TypeAppl ("->" TypeExpr)?
(diagram TypeExpr
	(sequence
	  (nonterminal TypeAppl)
	  (optional
	    (sequence
	      (terminal "->")
	      (nonterminal TypeExpr)))))

//TypeAppl ::= QTypeConstrID (SimpleTypeExpr))?
(diagram TypeAppl
	(sequence
	  (nonterminal QTypeConstrID)
	  (one-or-more (nonterminal SimpleTypeExpr))))

//SimpleTypeExpr
(diagram SimpleTypeExpr
	(sequence
	  (choice
	    (nonterminal QTypeConstrID)
	    (choice
	      (nonterminal TypeVarID)
	      (terminal "_"))
	    (terminal "()")
	    (sequence
	      (terminal "(")
	      (nonterminal TypeExpr)
	      (terminal ")"))
	    (sequence
	      (terminal "(")
	      (one-or-more (nonterminal TypeExpr))
	      (terminal ")"))
	    (sequence
	      (terminal "[")
	      (nonterminal TypeExpr)
	      (terminal "]")))))

//DataDeclaration
(diagram DataDeclaration
	(sequence
          (terminal "data")
          (nonterminal TypeDeclaration)))

//TypeDeclaration
(diagram TypeDeclaration
	(sequence
	  (nonterminal TypeConstrID)
	  (one-or-more (nonterminal TypeVarID))
	  (terminal "=")
	  (nonterminal ConstrDeclaration)))

//ConstrDeclaration
(diagram ConstrDeclaration
	(sequence
	  (nonterminal DataConstrID)
	  (one-or-more (nonterminal SimpleTypeExpr))))

//DataConstrID
(diagram DataConstrID
	(sequence
	  (nonterminal Identifier)))
	


//FunctionType ::= ( SimpleType ( "->" FunctionType )* )

(diagram FunctionType
        (sequence
	  (nonterminal SimpleType)
	  (zero-or-more 
	    (sequence
	      (terminal "->")
	      (nonterminal FunctionType)))))

//SimpleType ::= ( ( Identifier (ConstrArgType)* ) | CommonFactorType )

(diagram SimpleType
	(sequence
	  (choice
	    (sequence
	      (nonterminal Identifier)
	      (zero-or-more (nonterminal ConstrArgType)))
	    (nonterminal CommonFactorType))))

//ConstrArgType ::= Identifier | CommonFactorType

(diagram ConstrArgType
	(sequence
	  (choice
	    (nonterminal Identifier)
	    (nonterminal CommonFactorType))))

//CommonFactorType ::= ( Unit | Anonymous | "[" FunctionType "]" | "(" ( FunctionType ( ","
//	FunctionType )* ) ")" )

(diagram CommonFactorType
        (sequence
          (choice
	    (nonterminal Unit)
            (nonterminal Anonymous)
            (sequence
	      (terminal "[")
              (nonterminal FunctionType)
              (terminal "]"))
	    (sequence
            (terminal "(")
            (loop
             (nonterminal FunctionType)
             (terminal ","))
            (terminal ")")))))

//FunctionDeclaration ::= ( FunctionNonRuleDeclaration | FunctionInfixRuleDeclaration |
//	FunctionPrefixRuleDeclaration )

(diagram FunctionDeclaration 
	(sequence
	  (choice
	    (nonterminal Signature)
	    (nonterminal EvalAnnot)
	    (nonterminal Equat))))

//Signature
(diagram Signature
	(sequence
	  (nonterminal FunctionNames)
	  (terminal "::")
	  (nonterminal TypeExpr)))

//FunctionNames
(diagram FunctionNames
	(sequence
	  (loop
	    (nonterminal FunctionName)
	    (terminal ","))))

//EvalAnnot
(diagram EvalAnnot
	(sequence
	  (nonterminal FunctionNames)
	  (terminal "eval")
	  (nonterminal Annotation)))

//Annotation
(diagram Annotation
	(sequence
	  (choice
	    (terminal "flex")
	    (terminal "rigid")
	    (terminal "choice"))))

//Equat
(diagram Equat
	(sequence
	  (choice
	    (sequence
	      (nonterminal FunLHS)
	      (terminal "=")
	      (nonterminal Expr)
	      (optional
		(sequence
		  (terminal "where")
		  (nonterminal LocalDefs))))
	    (sequence
	      (nonterminal FunLHS)
	      (nonterminal CondExprs)
	      (optional
		(sequence
		  (terminal "where")
		  (nonterminal LocalDefs)))))))

//FunLHS
(diagram FunLHS
	(sequence
	  (choice
	    (sequence
	      (nonterminal FunctionName)
	      (one-or-more (nonterminal SimplePattern)))
	    (sequence
	      (nonterminal SimplePattern)
	      (nonterminal InfixOpID)
	      (nonterminal SimplePattern)))))

//Pattern
(diagram Pattern
	(sequence
	  (choice
	    (sequence
	      (nonterminal QDataConstrID)
	      (one-or-more (nonterminal Pattern))
	      (optional
		(sequence
		  (terminal ":")
		  (nonterminal Pattern))))
	    (sequence
	      (nonterminal SimplePattern)
	      (optional
		(sequence
	 	  (terminal ":")
		  (nonterminal Pattern)))))))

//QDataConstrID
(diagram QDataConstrID
	(sequence
	  (optional
	    (sequence
	      (nonterminal ModuleID)
	      (terminal ".")))
	  (nonterminal DataConstrID)))

//SimplePattern
(diagram SimplePattern
	(sequence
	  (choice
	    (sequence
	      (choice
	        (nonterminal VariableID)
		(terminal "_")))
	    (nonterminal QDataConstrID)
	    (nonterminal Literal)
	    (sequence
	      (terminal "(")
	      (loop
		(nonterminal Pattern)
		(terminal ","))
	      (terminal ")"))
	    (sequence
	      (terminal "(")
	      (nonterminal Pattern)
	      (terminal ")"))
	    (sequence
	      (terminal "[")
	      (loop
		(nonterminal Pattern)
		(terminal ","))
	      (terminal "]")))))

//VariableID
(diagram VariableID
	(sequence
	  (nonterminal Identifier)))

//LocalDefs
(diagram LocalDefs
	(sequence
	  (loop
	    (nonterminal ValueDeclaration)
	    (terminal ";"))))

//ValueDeclaration
(diagram ValueDeclaration
	(sequence
	  (choice
	    (nonterminal FunctionDeclaration)
	    (nonterminal PatternDeclaration)
	    (sequence
	      (loop
		(nonterminal VariableID)
		(terminal ","))
	      (terminal "free")))))

//PatternDeclaration
(diagram PatternDeclaration
	(sequence
	  (nonterminal Pattern)
	  (terminal "=")
	  (nonterminal Expr)
	  (optional
	    (sequence
	      (terminal "where")
	      (nonterminal LocalDefs)))))

//CondExprs
(diagram CondExprs
	(sequence
	  (terminal "|")
	  (nonterminal Expr)
	  (terminal "=")
	  (nonterminal Expr)
	  (optional
	    (nonterminal CondExprs))))
            
//Expr
(diagram Expr
	(sequence
	  (choice
	    (sequence
	      (terminal "\\\\")
	      (one-or-more (nonterminal SimplePattern))
	      (terminal "->")
	      (nonterminal Expr))
	    (sequence
	      (terminal "let")
	      (nonterminal LocalDefs)
	      (terminal "in")
	      (nonterminal Expr))
	    (sequence
	      (terminal "if")
	      (nonterminal Expr)
	      (terminal "then")
	      (nonterminal Expr)
	      (terminal "else")
	      (nonterminal Expr))
	    (sequence
	      (terminal "do")
	      (loop
	        (nonterminal Stmt)
		(terminal ";")))
	    (sequence
	      (nonterminal Expr)
	      (nonterminal QInfixOpID)
	      (nonterminal Expr))
	    (sequence
	      (terminal "-")
	      (nonterminal Expr))
	    (sequence
	      (nonterminal FunctExpr)))))

//FunctExpr
(diagram FunctExpr
	(sequence
	  (optional
	    (nonterminal FunctExpr))
	  (nonterminal BasicExpr)))

//BasicExpr
(diagram BasicExpr
	(sequence
	  (choice
	    (nonterminal QOptions)
	    (nonterminal Literal)
	    (terminal "()")
	    (nonterminal ExprOptions))))

//QOptions - Used to fit all of BasicExpr in applet
(diagram QOptions
	(sequence
	  (choice
	    (nonterminal QVariableID)
	    (nonterminal QDataConstrID)
	    (nonterminal QFunctionID)
	    (sequence
	      (terminal "(")
	      (nonterminal QInfixOpID)
	      (terminal ")")))))

//ExprOptions - Used to fix all of BasicExpr in applet
(diagram ExprOptions
	(sequence
	  (choice
	    (sequence
	      (terminal "(")
	      (nonterminal Expr)
	      (terminal ")"))
	    (sequence
	      (terminal "(")
	      (loop
		(nonterminal Expr)
		(terminal ","))
	      (terminal ")"))
	    (sequence
	      (terminal "[")
	      (loop
		(nonterminal Expr)
		(terminal ","))
	      (terminal "]"))
	    (sequence
	      (terminal "[")
	      (nonterminal Expr)
	      (optional
		(sequence
		  (terminal ",")
		  (one-or-more (nonterminal Expr))))
	      (terminal "]"))
	    (sequence
	      (terminal "[")
	      (nonterminal Expr)
	      (terminal "|")
	      (one-or-more (nonterminal Qual))
	      (terminal "]"))
	    (sequence
	      (terminal "(")
	      (nonterminal Expr)
	      (nonterminal QInfixOpID)
	      (terminal ")"))
	    (sequence
	      (terminal "(")
	      (nonterminal QInfixOpID)
	      (nonterminal Expr)
	      (terminal ")")))))

//Qual
(diagram Qual
	(sequence
	  (choice
	    (nonterminal Expr)
	    (sequence
	      (nonterminal Pattern)
	      (terminal "<-")
	      (nonterminal Expr)))))

//Stmt
(diagram Stmt
	(sequence
	  (choice
	    (nonterminal Expr)
	    (sequence
	      (terminal "let")
	      (nonterminal LocalDefs))
	    (sequence
	      (nonterminal Pattern)
	      (terminal "<-")
	      (nonterminal Expr)))))

//QVariableID
(diagram QVariableID
	(sequence
	  (optional
	    (sequence
	      (nonterminal ModuleID)
	      (terminal ".")))
	  (nonterminal VariableID)))

//Literal
(diagram Literal
	(sequence
	  (choice
	    (nonterminal Integer)
	    (nonterminal FloatLiteral)
	    (nonterminal CharLiteral)
	    (nonterminal StringLiteral))))

//FunctionNonRuleDeclaration ::= ( Prefixed ( "," Prefixed )* ) ( "::" FunctionType 
//	| "eval" Annotation)

(diagram FunctionNonRuleDeclaration
	(sequence
	  (loop
            (nonterminal Prefixed)
            (terminal ","))
	  (choice
	    (sequence
	      (terminal "::")
	      (nonterminal FunctionType))
	    (sequence
	      (terminal "eval")
	      (nonterminal Annotation)))))


//
//SYMBOL
//
(regularexp Symbol (" [ \"~\",  \"!\",  \"@\",  \"#\",  \"$\",  \"%\", \"^\",\"&\",  \"*\",  \"+\",  \"=\", \":\",  \"<\",  \">\",  \"?\",  \".\", \"|\" ,\"/\", \"\\\\\" ] " ) )
      

(diagram InfixOpID
       (sequence
         (nonterminal Symbol)
         (zero-or-more
            (nonterminal Symbol))))
 
//Prefixed ::= Identifier | "(" (<INFIXOP> | "-") ")"

(diagram Prefixed
	(sequence
	  (choice
	    (nonterminal Identifier)
	    (sequence
	      (terminal "(")
	      (choice
	        (nonterminal InfixOpID)
	        (terminal "-"))
	      (terminal ")")))))	

//FunctionPrefixRuleDeclaration ::= Identifier ( Pattern )* HeadLessEquation

(diagram FunctionPrefixRuleDeclaration
	(sequence
	  (nonterminal Identifier)
	  (zero-or-more (nonterminal Pattern))
	  (nonterminal HeadLessEquation)))


//FunctionInfixRuleDeclaration ::= Pattern Infixed Pattern HeadLessEquation

(diagram FunctionInfixRuleDeclaration
	(sequence
	  (nonterminal Pattern)
          (nonterminal Infixed)
          (nonterminal Pattern)
          (nonterminal HeadLessEquation)))


//EvalTree ::= ( Branch | "rule" ) ( ( "or" | "and" ) EvalTree )*

(diagram EvalTree
	(sequence
	  (choice
	    (nonterminal Branch)
	    (terminal "rule"))
	  (zero-or-more 
	    (sequence
	      (choice
	        (terminal "or")
                (terminal "and"))
	      (nonterminal EvalTree)))))


(regularexp Space (" ( [\" \",\"\\n\", \"\\r\" ] ) *" ) )

(diagram Position
  (sequence
     (nonterminal Integer)
     (zero-or-more 
          (sequence
                   ( nonterminal Space)
                   (terminal ".")
                   (nonterminal Space)
                   (nonterminal Integer)))
     (nonterminal Space)
     (terminal "::")))


//Branch ::= <POSITION> ( "flex" | "rigid" ) ( "(" ( ConstrAnnotation )+ ")" )?

(diagram Branch
        (sequence
	  (nonterminal Position)
	  (choice
            (terminal "flex")
            (terminal "rigid"))
	  (optional
	    (sequence
	      (terminal "(")
	      (one-or-more (nonterminal ConstrAnnotation))
              (terminal ")")))))

//InnerDeclarationList ::= ( ( InnerDeclaration ) )+ 
(diagram InnerDeclarationList
	(sequence
	  (one-or-more (nonterminal InnerDeclaration))))

//InnerDeclaration ::= FreeDeclaration | FunctionDeclaration | PatternDeclaration

(diagram InnerDeclaration
	(sequence
	  (choice
	    (nonterminal FreeDeclaration)
            (nonterminal FunctionDeclaration)
            (nonterminal PatternDeclaration))))

//FreeDeclaration ::= Identifier ( "," Identifier )* "free"

(diagram FreeDeclaration
	(sequence
          (loop
            (nonterminal Identifier)
            (terminal ","))
          (terminal "free")))


//Identifier ::= <IDENTIFIER>


(regularexp Identifier  ("( [ \"a\" - \"z\",\"A\" - \"Z\"]) (([\"a\" - \"z\",\"A\" - \"Z\", \"0\" - \"9\"]) | (\"_\"))*")) 

(regularexp ModuleIdentifier  ("( [ \"a\" - \"z\",\"A\" - \"Z\"]) (([\"a\" - \"z\",\"A\" - \"Z\", \"0\" - \"9\"]) | (\"_\") | (\".\"))*")) 

//Infixed ::= ( ( <INFIXOP> | ":" | "-" ) | "`" Identifier "`" )


(diagram Infixed
	(sequence
	  (choice
	    (choice
	      (nonterminal InfixOpID)
	      (terminal ":")
              (terminal "-"))
	    (sequence
	      (terminal "`")
              (nonterminal Identifier)
              (terminal "`")))))

//ConstrAnnotation ::= ( Atomic | ListConstr ) "=>" EvalTree

(diagram ConstrAnnotation
	(sequence
	  (choice
	    (nonterminal Atomic)
            (nonterminal ListConstr))
	  (terminal "=>")
	  (nonterminal EvalTree)))

//ListConstr ::= ( <NIL> | ":" )

(diagram ListConstr
        (sequence
	  (choice
	    (nonterminal Nil)
	    (terminal ":"))))

//HeadLessEquation ::= ( "=" Expr | ( "|" ( Expr | NonConstraintExpr ) "=" Expr )+ ) ( (
//                            "where" InnerDeclarationList )? )

(diagram HeadLessEquation
	(sequence
	  (choice
	    (sequence
	      (terminal "=")
	      (nonterminal Expr))
	    (optional
	      (sequence
	        (terminal "|")
	        (choice
		  (nonterminal Expr)
		  (nonterminal NonConstraintExpr))
	        (terminal "=")
	        (nonterminal Expr))))
	  (optional 
	    (sequence
	      (terminal "where")
              (nonterminal InnerDeclarationList)))))

//NonConstraintExpr ::= Expr

(diagram NonConstraintExpr
	(sequence
	  (nonterminal Expr)))

(regularexp StringLiteral ("\"\\\" ( (~[ \"\\\",\"\\\\\", \"\\n\", \"\\r\"] ) | (\"\\\\\" ( [\"n\", \"t\", \"b\", \"r\", \"f\", \"\\\\\", \"'\", \"\\\" ] |[\"0\" - \"7\"] ( [\"0\" - \"7\" ] )? | [ \"0\" - \"3\" ] [ \"0\" - \"7\" ] [\"0\" - \"7\" ] ) ) ) * \"\\\""))

(regularexp CharLiteral ("\"'\" ( ( ~[\"'\", \"\\\\\", \"\\n\", \"\\r\" ] ) | ( \"\\\\\" ( [ \"n\", \"t\", \"b\",\"r\", \"f\", \"\\\\\", \"'\", \"\\\" ] \"|\" [ \"0\" - \"7\"] ( [ \"0\" - \"7\"] ) ? \"|\"  [ \"0\" - \"3\" ] [ \"0\"- \"7\" ] [ \"0\" - \"7\" ] ) ) )") )

//(regularexp CharLiteral (" \"\\\\\" ") )

(regularexp Exponent ("[ \"e\", \"E\" ] ( [ \"+\", \"-\" ] ) ? ( [ \"0\" - \"9\" ] ) + "))

(diagram FloatLiteral 
    (sequence
        (choice
            (sequence
                (one-or-more (terminal "[ 0 - 9 ]") )
                (terminal ".")
                (zero-or-more (terminal "[ 0 - 9 ] "))
                (optional (nonterminal Exponent))
                 ) 
            (sequence
                (one-or-more (terminal "[ 0 - 9 ]") )
                (nonterminal Exponent) )
            (sequence
                (terminal ".")
                (one-or-more (terminal "[ 0 - 9 ]") )
                ( optional (nonterminal Exponent) ) )
            (sequence
                (one-or-more (terminal "[ 0 - 9 ]") )
                ( optional (nonterminal Exponent) ) ) ) ))
 
       

                

//Atomic ::= Anonymous
//          | Unit
//          | Nil
//          | Identifier
//          | Integer
//          | <FLOAT_LITERAL>
//          | <CHAR_LITERAL>
//          | <STRING_LITERAL>

(diagram Atomic
	(sequence
	 (choice
	   (nonterminal Anonymous)
	   (nonterminal Unit)
	   (nonterminal Nil)
	   (nonterminal Identifier)
	   (nonterminal Integer)
	   (nonterminal FloatLiteral)
	   (nonterminal CharLiteral)
	   (nonterminal StringLiteral))))

//AtomicExtra ::= Atomic | ExtraVariable

(diagram AtomicExtra
	(sequence
	  (choice 
	    (nonterminal Atomic)
            (nonterminal ExtraVariable))))

//Unit ::= <UNIT>
//CHECK IT LATER
 (regularexp Unit ("\"(\" ([\" \", \"\\n\", \"\\r\"])* \")\"  " ))
  
 
//Nil ::= <NIL>

(regularexp Nil ("\"[\" ([ \" \", \"\\n\", \"\\r\"])* \"]\""))


//ExtraVariable ::= <EXTRAVARIABLE>

(diagram ExtraVariable
        (sequence
          (terminal "_")
          (nonterminal Identifier)))
 
//Anonymous ::= "_"

(regularexp Anonymous ("\"_\""))

//(regularexp Anonymous ("\" \""))

//DECIMAL_LITERAL
 (regularexp Decimal ("[ \"1\" - \"9\" ] ( [ \"0\" - \"9\" ] ) *" ) )
  

//HEX_LITERAL
 (regularexp Hexadecimal ("\"0\" [\"x\" , \"X\" ] ( [ \"0\" - \"9\", \"a\" -\"f\", \"A\" - \"F\" ] ) + ") )

//OCTAL
(regularexp Octal ("\"0\" ( [ \"0\" - \"7\" ] ) * ") )
 
//Integer ::= <INTEGER_LITERAL>

(diagram Integer
	(sequence
           (choice 
           (nonterminal Hexadecimal)
           (nonterminal Decimal)
           (nonterminal Octal))))


//ConsPattern ::= ( ApplicPattern ( ":" ConsPattern )? )


(diagram ConsPattern
	(sequence 
	  (nonterminal ApplicPattern)
	  (optional
	    (sequence 
	      (terminal ":")
	      (nonterminal ConsPattern)))))

//ApplicPattern ::= ( Pattern )+

(diagram ApplicPattern
	(sequence (one-or-more (nonterminal "Pattern"))))

//Operator ::= Infixed

(diagram Operator
	(sequence
	  (nonterminal Infixed)))


//(diagram
//Operand ::= ( ( "(" ( <INFIXOP> | ":" | "-" ) ")" ) | AtomicExtra | ( "choice" 
//	ChoicePair ( "," ChoicePair )* ) | ( "\\" ( Pattern )+ "->" Expr ) | 
//	( "let" InnerDeclarationList "in" Expr ) | ( "if" Expr "then" Expr "else" Expr ) 
//	| ( "[" Expr ( "," Expr )* "]" ) | ( "{" ( ConstraintExpr ( "," ConstraintExpr )* )?
//	 "}" ) | ( "(" Expr ( "," Expr )* ")" ) | Section )

//ChoicePair ::= Expr "->" Expr ( ( "where" InnerDeclarationList )? )

 

(diagram Operand
 (sequence
     (choice
         
         (sequence
              (one-or-more ( nonterminal Pattern) )
              (terminal "->")
              (nonterminal Expr))
         (nonterminal AtomicExtra)
         (nonterminal Section)
         (sequence
           (terminal "let")
           (nonterminal InnerDeclarationList)
           (terminal "in")
           (nonterminal Expr))
         (sequence
           (terminal "if")
           (nonterminal Expr)
           (terminal "then")
           (nonterminal Expr)
           (terminal "then")
           (nonterminal Expr) )
         (sequence
           (terminal "[")
           (nonterminal Expr)
           (zero-or-more
                (sequence
                   (terminal ",")
                   (nonterminal Expr) ) )
           (terminal "]"))
         (sequence
           ( terminal "choice")
           ( nonterminal ChoicePair)
           ( zero-or-more
                  (sequence
                     (terminal ",")
                     (nonterminal ChoicePair)))))))

 
 

(diagram ChoicePair
        (sequence
          (nonterminal Expr)
	  (terminal "->")
	  (nonterminal Expr)
	  (optional
	    (sequence
	      (terminal "where")
	      (nonterminal InnerDeclarationList)))))

//ConstraintExpr ::= ( Expr ( "=" Expr )? )

(diagram ConstraintExpr
	(sequence
	  (nonterminal Expr)
	  (optional
	    (sequence
	      (terminal "=")
	      (nonterminal Expr)))))

//Section ::= "(" ( Operator Operand | Operand Operator ) ")"

(diagram Section
	(sequence
	  (terminal "(")
	  (choice
	    (sequence
	      (nonterminal Operator)
              (nonterminal Operand))
	    (sequence
              (nonterminal Operand)
	      (nonterminal Operator)))
	  (terminal ")")))