Merge branch 'derive-ToJSONFields1' into explicit-statements

src/Data/Syntax/Declaration.hs

@@ -194,7 +194,7 @@ instance Evaluatable Data.Syntax.Declaration.Datatype
 
 
 -- | A single constructor in a datatype, or equally a 'struct' in C, Rust, or Swift.
-data Constructor a = Constructor { constructorName :: !a, constructorFields :: ![a] }
+data Constructor a = Constructor { constructorName :: !a, constructorFields :: !a }
   deriving (Eq, Ord, Show, Foldable, Traversable, Functor, Generic1, Hashable1, Diffable, Mergeable, FreeVariables1, Declarations1, ToJSONFields1)
 
 instance Eq1 Data.Syntax.Declaration.Constructor where liftEq = genericLiftEq

src/Data/Syntax/Type.hs

@@ -6,7 +6,7 @@ import Data.JSON.Fields
 import Diffing.Algorithm
 import Prologue hiding (Map)
 
-data Array a = Array { arraySize :: Maybe a, arrayElementType :: a }
+data Array a = Array { arraySize :: !(Maybe a), arrayElementType :: !a }
   deriving (Eq, Ord, Show, Foldable, Traversable, Functor, Generic1, Hashable1, Diffable, Mergeable, FreeVariables1, Declarations1, ToJSONFields1)
 
 instance Eq1 Array where liftEq = genericLiftEq
@@ -30,7 +30,7 @@ instance Evaluatable Annotation where
   eval Annotation{annotationSubject = Subterm _ action} = action
 
 
-data Function a = Function { functionParameters :: [a], functionReturn :: a }
+data Function a = Function { functionParameters :: ![a], functionReturn :: !a }
   deriving (Eq, Ord, Show, Foldable, Traversable, Functor, Generic1, Hashable1, Diffable, Mergeable, FreeVariables1, Declarations1, ToJSONFields1)
 
 instance Eq1 Function where liftEq = genericLiftEq
@@ -52,7 +52,7 @@ instance Show1 Interface where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Interface
 
 
-data Map a = Map { mapKeyType :: a, mapElementType :: a }
+data Map a = Map { mapKeyType :: !a, mapElementType :: !a }
   deriving (Eq, Ord, Show, Foldable, Traversable, Functor, Generic1, Hashable1, Diffable, Mergeable, FreeVariables1, Declarations1, ToJSONFields1)
 
 instance Eq1 Map where liftEq = genericLiftEq

src/Language/Go/Assignment.hs

@@ -307,7 +307,7 @@ sliceType :: Assignment
 sliceType = makeTerm <$> symbol SliceType <*> children (Type.Slice <$> expression)
 
 structType :: Assignment
-structType = makeTerm <$> symbol StructType <*> children (Declaration.Constructor <$> emptyTerm <*> manyTerm expression)
+structType = makeTerm <$> symbol StructType <*> children (Declaration.Constructor <$> emptyTerm <*> expressions)
 
 typeAlias :: Assignment
 typeAlias = makeTerm <$> symbol TypeAlias <*> children (Declaration.TypeAlias [] <$> expression <*> expression)

src/Language/Haskell/Assignment.hs

@@ -10,7 +10,7 @@ import Assigning.Assignment hiding (Assignment, Error, count)
 import Data.ByteString.Char8 (count)
 import Data.Record
 import Data.Sum
-import Data.Syntax (emptyTerm, handleError, parseError, makeTerm, makeTerm'', contextualize, postContextualize)
+import Data.Syntax (emptyTerm, handleError, parseError, makeTerm, makeTerm', makeTerm'', contextualize, postContextualize)
 import Language.Haskell.Grammar as Grammar
 import qualified Assigning.Assignment as Assignment
 import qualified Data.Abstract.Name as Name
@@ -25,6 +25,8 @@ import Prologue
 
 type Syntax = '[
     Comment.Comment
+  , Declaration.Constructor
+  , Declaration.Datatype
   , Declaration.Function
   , Literal.Array
   , Literal.Character
@@ -34,10 +36,15 @@ type Syntax = '[
   , Syntax.Context
   , Syntax.Empty
   , Syntax.Error
+  , Syntax.Field
   , Syntax.FunctionConstructor
   , Syntax.Identifier
   , Syntax.ListConstructor
   , Syntax.Module
+  , Syntax.Pragma
+  , Syntax.RecordDataConstructor
+  , Syntax.StrictType
+  , Syntax.StrictTypeVariable
   , Syntax.TupleConstructor
   , Syntax.Type
   , Syntax.TypeSynonym
@@ -67,7 +74,8 @@ expression = term (handleError (choice expressionChoices))
 
 expressionChoices :: [Assignment.Assignment [] Grammar Term]
 expressionChoices = [
-                      character
+                      algebraicDatatypeDeclaration
+                    , character
                     , comment
                     , constructorIdentifier
                     , float
@@ -78,6 +86,7 @@ expressionChoices = [
                     , listExpression
                     , listType
                     , moduleIdentifier
+                    , strictType
                     , string
                     , type'
                     , typeConstructorIdentifier
@@ -90,14 +99,35 @@ expressionChoices = [
                     ]
 
 term :: Assignment -> Assignment
-term term = contextualize comment (postContextualize comment term)
+term term = contextualize (comment <|> pragma) (postContextualize (comment <|> pragma) term)
+
+algebraicDatatypeDeclaration :: Assignment
+algebraicDatatypeDeclaration = makeTerm
+                            <$> symbol AlgebraicDatatypeDeclaration
+                            <*> children (Declaration.Datatype
+                                        <$> (makeTerm <$> location <*> (Syntax.Type <$> typeConstructor <*> typeParameters))
+                                        <*> ((symbol Constructors *> children (many constructor))
+                                            <|> pure []))
 
 comment :: Assignment
 comment = makeTerm <$> symbol Comment <*> (Comment.Comment <$> source)
 
+constructor :: Assignment
+constructor =  (makeTerm <$> symbol DataConstructor <*> children (Declaration.Constructor <$> typeConstructor <*> typeParameters))
+           <|> (makeTerm <$> symbol RecordDataConstructor <*> children (Syntax.RecordDataConstructor <$> constructorIdentifier <*> fields))
+
+fields :: Assignment
+fields = makeTerm <$> symbol Fields <*> children (many field)
+
+field :: Assignment
+field = makeTerm <$> symbol Field <*> children (Syntax.Field <$> variableIdentifiers <* token Annotation <*> term type')
+
 variableIdentifier :: Assignment
 variableIdentifier = makeTerm <$> symbol VariableIdentifier <*> (Syntax.Identifier . Name.name <$> source)
 
+variableIdentifiers :: Assignment
+variableIdentifiers = makeTerm <$> location <*> many variableIdentifier
+
 constructorIdentifier :: Assignment
 constructorIdentifier = makeTerm <$> symbol ConstructorIdentifier <*> (Syntax.Identifier . Name.name <$> source)
 
@@ -134,6 +164,9 @@ integer = makeTerm <$> symbol Integer <*> (Literal.Integer <$> source)
 listConstructor :: Assignment
 listConstructor = makeTerm <$> token ListConstructor <*> pure Syntax.ListConstructor
 
+pragma :: Assignment
+pragma = makeTerm <$> symbol Pragma <*> (Syntax.Pragma <$> source)
+
 unitConstructor :: Assignment
 unitConstructor = makeTerm <$> token UnitConstructor <*> pure Syntax.UnitConstructor
 
@@ -144,6 +177,10 @@ listExpression = makeTerm <$> symbol ListExpression <*> children (Literal.Array
 listType :: Assignment
 listType = makeTerm <$> symbol ListType <*> children (Literal.Array <$> many type')
 
+strictType :: Assignment
+strictType = makeTerm' <$> symbol StrictType <*> children ((inject <$> (Syntax.StrictType <$> typeConstructor <*> typeParameters))
+                                                        <|> (inject <$> (Syntax.StrictTypeVariable <$> typeVariableIdentifier)))
+
 tuplingConstructor :: Assignment
 tuplingConstructor = makeTerm <$> symbol TuplingConstructor <*> (tupleWithArity <$> source)
         -- a tuple (,) has arity two, but only one comma, so apply the successor to the count of commas for the correct arity.
@@ -152,6 +189,8 @@ tuplingConstructor = makeTerm <$> symbol TuplingConstructor <*> (tupleWithArity
 type' :: Assignment
 type' = (makeTerm <$> symbol Type <*> children (Syntax.Type <$> typeConstructor <*> typeParameters))
      <|> (makeTerm <$> symbol TypePattern <*> children (Syntax.Type <$> typeConstructor <*> typeParameters))
+     <|> strictType
+     <|> typeConstructor
 
 typeParameters :: Assignment
 typeParameters = makeTerm <$> location <*> (Type.TypeParameters <$> many expression)
@@ -172,6 +211,7 @@ typeConstructor = typeConstructorIdentifier
                <|> listType
                <|> tuplingConstructor
                <|> unitConstructor
+               <|> constructorIdentifier
 
 typeSynonymDeclaration :: Assignment
 typeSynonymDeclaration = makeTerm

src/Language/Haskell/Syntax.hs

@@ -19,6 +19,28 @@ instance Show1 Module where liftShowsPrec = genericLiftShowsPrec
 
 instance Evaluatable Module
 
+data StrictType a = StrictType { strictTypeIdentifier :: !a, strictTypeParameters :: !a }
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+
+instance Eq1 StrictType where liftEq = genericLiftEq
+instance Ord1 StrictType where liftCompare = genericLiftCompare
+instance Show1 StrictType where liftShowsPrec = genericLiftShowsPrec
+
+instance ToJSONFields1 StrictType
+
+instance Evaluatable StrictType
+
+newtype StrictTypeVariable a = StrictTypeVariable { strictTypeVariableIdentifier :: a }
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+
+instance Eq1 StrictTypeVariable where liftEq = genericLiftEq
+instance Ord1 StrictTypeVariable where liftCompare = genericLiftCompare
+instance Show1 StrictTypeVariable where liftShowsPrec = genericLiftShowsPrec
+
+instance ToJSONFields1 StrictTypeVariable
+
+instance Evaluatable StrictTypeVariable
+
 data Type a = Type { typeIdentifier :: !a, typeParameters :: !a }
   deriving (Eq, Ord, Show, Foldable, Traversable, Functor, Generic1, Hashable1, Diffable, Mergeable, FreeVariables1, Declarations1, ToJSONFields1)
 
@@ -68,3 +90,33 @@ instance Ord1 FunctionConstructor where liftCompare = genericLiftCompare
 instance Show1 FunctionConstructor where liftShowsPrec = genericLiftShowsPrec
 
 instance Evaluatable FunctionConstructor
+
+data RecordDataConstructor a = RecordDataConstructor { recordDataConstructorName :: !a, recordDataConstructorFields :: !a } deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+
+instance Eq1 RecordDataConstructor where liftEq = genericLiftEq
+instance Ord1 RecordDataConstructor where liftCompare = genericLiftCompare
+instance Show1 RecordDataConstructor where liftShowsPrec = genericLiftShowsPrec
+
+instance ToJSONFields1 RecordDataConstructor
+
+instance Evaluatable RecordDataConstructor
+
+data Field a = Field { fieldName :: !a, fieldBody :: !a } deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+
+instance Eq1 Field where liftEq = genericLiftEq
+instance Ord1 Field where liftCompare = genericLiftCompare
+instance Show1 Field where liftShowsPrec = genericLiftShowsPrec
+
+instance ToJSONFields1 Field
+
+instance Evaluatable Field
+
+newtype Pragma a = Pragma ByteString deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+
+instance Eq1 Pragma where liftEq = genericLiftEq
+instance Ord1 Pragma where liftCompare = genericLiftCompare
+instance Show1 Pragma where liftShowsPrec = genericLiftShowsPrec
+
+instance ToJSONFields1 Pragma
+
+instance Evaluatable Pragma

test/fixtures/haskell/corpus/algebraic-datatype-declarations.A.hs

@@ -0,0 +1,18 @@
+data N
+data N a = N a
+data N a = N !a
+data N a b = N !a b
+
+data B = A
+       | A0
+       | A9
+       | Aa
+       | A_
+       | Az'
+
+data N = N { a :: Int }
+data N = N { a, b :: Int }
+data N = N { a :: !Int, b :: Int }
+data N = N { a, b :: {-#  UNPACK #-} !Int, c :: String }
+data N = N { a :: Int } | O { b :: String }
+data N = N { b :: Int } | O { c :: String }

test/fixtures/haskell/corpus/algebraic-datatype-declarations.B.hs

@@ -0,0 +1,18 @@
+data O
+data O a = O a
+data O a = O !a
+data O a b = O !a b
+
+data A = B
+       | B0
+       | B9
+       | Ba
+       | B_
+       | Bz'
+
+data O = O { a :: Int }
+data O = O { a, b :: Int }
+data O = O { a :: !Int, b :: Int }
+data O = O { a, b :: {-#  UNPACK #-} !Int, c :: String }
+data N = N { b :: Int } | O { c :: String }
+data N = N { b :: Text } | O { c :: Bool }

test/fixtures/haskell/corpus/algebraic-datatype-declarations.diffA-B.txt

@@ -0,0 +1,208 @@
+(Module
+  (Empty)
+  (Statements
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters)))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier)
+          (Identifier)))
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier))
+          (Identifier))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-})
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (StrictType
+              (Identifier)
+              (TypeParameters)))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Context
+              (Pragma)
+              (StrictType
+                (Identifier)
+                (TypeParameters))))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+  {-(Datatype
+    {-(Type
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(RecordDataConstructor
+      {-(Identifier)-}
+      {-(Statements
+        {-(Field
+          {-(Statements
+            {-(Identifier)-})-}
+          {-(Identifier)-})-})-})-}
+    {-(RecordDataConstructor
+      {-(Identifier)-}
+      {-(Statements
+        {-(Field
+          {-(Statements
+            {-(Identifier)-})-}
+          {-(Identifier)-})-})-})-})-}
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier))))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+  {+(Datatype
+    {+(Type
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(RecordDataConstructor
+      {+(Identifier)+}
+      {+(Statements
+        {+(Field
+          {+(Statements
+            {+(Identifier)+})+}
+          {+(Identifier)+})+})+})+}
+    {+(RecordDataConstructor
+      {+(Identifier)+}
+      {+(Statements
+        {+(Field
+          {+(Statements
+            {+(Identifier)+})+}
+          {+(Identifier)+})+})+})+})+}))

test/fixtures/haskell/corpus/algebraic-datatype-declarations.diffB-A.txt

@@ -0,0 +1,202 @@
+(Module
+  (Empty)
+  (Statements
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters)))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (Identifier)
+          (Identifier)))
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier))
+          (Identifier))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (Constructor
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(Identifier)-}
+      {-(TypeParameters)-})-})
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (StrictType
+              (Identifier)
+              (TypeParameters)))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+      { (Identifier)
+      ->(Identifier) }
+        (TypeParameters))
+      (RecordDataConstructor
+      { (Identifier)
+      ->(Identifier) }
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Context
+              (Pragma)
+              (StrictType
+                (Identifier)
+                (TypeParameters))))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+  {+(Datatype
+    {+(Type
+      {+(Identifier)+}
+      {+(TypeParameters)+})+}
+    {+(RecordDataConstructor
+      {+(Identifier)+}
+      {+(Statements
+        {+(Field
+          {+(Statements
+            {+(Identifier)+})+}
+          {+(Identifier)+})+})+})+}
+    {+(RecordDataConstructor
+      {+(Identifier)+}
+      {+(Statements
+        {+(Field
+          {+(Statements
+            {+(Identifier)+})+}
+          {+(Identifier)+})+})+})+})+}
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier))))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+  {-(Datatype
+    {-(Type
+      {-(Identifier)-}
+      {-(TypeParameters)-})-}
+    {-(RecordDataConstructor
+      {-(Identifier)-}
+      {-(Statements
+        {-(Field
+          {-(Statements
+            {-(Identifier)-})-}
+          {-(Identifier)-})-})-})-}
+    {-(RecordDataConstructor
+      {-(Identifier)-}
+      {-(Statements
+        {-(Field
+          {-(Statements
+            {-(Identifier)-})-}
+          {-(Identifier)-})-})-})-})-}))

test/fixtures/haskell/corpus/algebraic-datatype-declarations.parseA.txt

@@ -0,0 +1,156 @@
+(Module
+  (Empty)
+  (Statements
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters)))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+        (Identifier)
+        (TypeParameters
+          (Identifier))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+        (Identifier)
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters
+          (Identifier)
+          (Identifier)))
+      (Constructor
+        (Identifier)
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier))
+          (Identifier))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters)))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (StrictType
+              (Identifier)
+              (TypeParameters)))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Context
+              (Pragma)
+              (StrictType
+                (Identifier)
+                (TypeParameters))))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier))))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier))))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))))

test/fixtures/haskell/corpus/algebraic-datatype-declarations.parseB.txt

@@ -0,0 +1,156 @@
+(Module
+  (Empty)
+  (Statements
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters)))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+        (Identifier)
+        (TypeParameters
+          (Identifier))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters
+          (Identifier)))
+      (Constructor
+        (Identifier)
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters
+          (Identifier)
+          (Identifier)))
+      (Constructor
+        (Identifier)
+        (TypeParameters
+          (StrictTypeVariable
+            (Identifier))
+          (Identifier))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters))
+      (Constructor
+        (Identifier)
+        (TypeParameters)))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (StrictType
+              (Identifier)
+              (TypeParameters)))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier)
+              (Identifier))
+            (Context
+              (Pragma)
+              (StrictType
+                (Identifier)
+                (TypeParameters))))
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier))))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))
+    (Datatype
+      (Type
+        (Identifier)
+        (TypeParameters))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier))))
+      (RecordDataConstructor
+        (Identifier)
+        (Statements
+          (Field
+            (Statements
+              (Identifier))
+            (Identifier)))))))

test/fixtures/haskell/corpus/blank.parseA.txt

@@ -1,3 +1,3 @@
 (Module
   (Empty)
-  ([]))
+  (Statements))

test/fixtures/haskell/corpus/literals.diffA-B.txt

@@ -1,233 +1,234 @@
 (Module
   (Identifier)
-  (
+  (Statements
+    (Function
+    { (Identifier)
+    ->(Identifier) }
+      (Statements
+        (Integer)))
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
-      {+(Integer)+})+})+}
-  {+(Function
-    {+(Identifier)+}
-    {+(
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Array
         {+(TextElement)+}
         {+(TextElement)+}
@@ -265,231 +266,227 @@
         {+(TextElement)+})+})+})+}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
-      {-(Integer)-})-})-}
-  {-(Function
-    {-(Identifier)-}
-    {-(
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Array
         {-(TextElement)-}
         {-(TextElement)-}

test/fixtures/haskell/corpus/literals.diffB-A.txt

@@ -1,235 +1,236 @@
 (Module
   (Identifier)
-  (
+  (Statements
+    (Function
+    { (Identifier)
+    ->(Identifier) }
+      (Statements
+        (Integer)))
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Integer)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
-      {+(Integer)+})+})+}
-  {+(Function
-    {+(Identifier)+}
-    {+(
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
     (Function
     { (Identifier)
     ->(Identifier) }
-      (
+      (Statements
       {+(Float)+}
       {-(Integer)-}))
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Float)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Identifier)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Character)+})+})+}
   {+(Function
     {+(Identifier)+}
-    {+(
+    {+(Statements
       {+(Array
         {+(TextElement)+}
         {+(TextElement)+}
@@ -267,227 +268,223 @@
         {+(TextElement)+})+})+})+}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Integer)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
-      {-(Integer)-})-})-}
-  {-(Function
-    {-(Identifier)-}
-    {-(
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Float)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Identifier)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Character)-})-})-}
   {-(Function
     {-(Identifier)-}
-    {-(
+    {-(Statements
       {-(Array
         {-(TextElement)-}
         {-(TextElement)-}

test/fixtures/haskell/corpus/literals.parseA.txt

@@ -1,233 +1,233 @@
 (Module
   (Identifier)
-  (
+  (Statements
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Array
           (TextElement)
           (TextElement)

test/fixtures/haskell/corpus/literals.parseB.txt

@@ -1,233 +1,233 @@
 (Module
   (Identifier)
-  (
+  (Statements
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Integer)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Float)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Identifier)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Character)))
     (Function
       (Identifier)
-      (
+      (Statements
         (Array
           (TextElement)
           (TextElement)

test/fixtures/haskell/corpus/type-synonyms.diffA-B.txt

@@ -1,6 +1,6 @@
 (Module
   (Empty)
-  (
+  (Statements
     (TypeSynonym
       (Type
       { (Identifier)

test/fixtures/haskell/corpus/type-synonyms.diffB-A.txt

@@ -1,6 +1,6 @@
 (Module
   (Empty)
-  (
+  (Statements
     (TypeSynonym
       (Type
       { (Identifier)

test/fixtures/haskell/corpus/type-synonyms.parseA.txt

@@ -1,6 +1,6 @@
 (Module
   (Empty)
-  (
+  (Statements
     (TypeSynonym
       (Type
         (Identifier)

test/fixtures/haskell/corpus/type-synonyms.parseB.txt

@@ -1,6 +1,6 @@
 (Module
   (Empty)
-  (
+  (Statements
     (TypeSynonym
       (Type
         (Identifier)