Merge branch 'master' into topologically-sorted-imports

2024-11-29 02:44:36 +03:00 · 2018-06-25 17:43:26 -04:00 · 2018-06-25 17:43:26 -04:00 · 45262b585e
commit 45262b585e
parent 9526d365d6 78d4d444a0
54 changed files with 11203 additions and 2158 deletions
--- a/src/Assigning/Assignment.hs
+++ b/src/Assigning/Assignment.hs
@ -243,7 +243,7 @@ nodeError expected Node{..} = Error nodeSpan expected (Just (Right nodeSymbol))

 firstSet :: (Enum grammar, Ix grammar) => Assignment ast grammar a -> [grammar]
 firstSet = iterFreer (\ _ (Tracing _ assignment) -> case assignment of
-  Choose table _ _ -> Table.tableAddresses table
+  Choose table _ _ -> Table.tableAddresses table
  Label child _ -> firstSet child
  _ -> []) . ([] <$)

--- a/src/Data/Diff.hs
+++ b/src/Data/Diff.hs
@ -142,7 +142,7 @@ instance (Show1 syntax, Show ann1, Show ann2) => Show (Diff syntax ann1 ann2) wh
 instance Show1 syntax => Show3 (DiffF syntax) where
  liftShowsPrec3 sp1 sl1 sp2 sl2 spRecur slRecur d diff = case diff of
    Patch patch -> showsUnaryWith (liftShowsPrec2 (liftShowsPrec2 sp1 sl1 spRecur slRecur) (liftShowList2 sp1 sl1 spRecur slRecur) (liftShowsPrec2 sp2 sl2 spRecur slRecur) (liftShowList2 sp2 sl2 spRecur slRecur)) "Patch" d patch
-    Merge term  -> showsUnaryWith (liftShowsPrec2 spBoth slBoth spRecur slRecur) "Merge" d term
+    Merge term -> showsUnaryWith (liftShowsPrec2 spBoth slBoth spRecur slRecur) "Merge" d term
    where spBoth = liftShowsPrec2 sp1 sl1 sp2 sl2
          slBoth = liftShowList2 sp1 sl1 sp2 sl2

--- a/src/Data/Functor/Classes/Generic.hs
+++ b/src/Data/Functor/Classes/Generic.hs
@ -131,7 +131,7 @@ instance (Ord1 f, GOrd1 g) => GOrd1 (f :.: g) where


 instance GShow1 U1 where
-  gliftShowsPrec _ _ _ _ _ = id
+  gliftShowsPrec _ _ _ _ _ = id

 instance GShow1 Par1 where
  gliftShowsPrec _ sp _ d (Par1 a) = sp d a
@ -149,7 +149,7 @@ instance (Constructor c, GShow1Body f) => GShow1 (M1 C c f) where
  gliftShowsPrec opts sp sl d m = gliftShowsPrecBody opts (conFixity m) (conIsRecord m && optionsUseRecordSyntax opts) (conName m) sp sl d (unM1 m)

 instance GShow1Body U1 where
-  gliftShowsPrecBody _ _ _ conName _ _ _ _ = showString conName
+  gliftShowsPrecBody _ _ _ conName _ _ _ _ = showString conName

 instance (Selector s, GShow1 f) => GShow1Body (M1 S s f) where
  gliftShowsPrecBody opts _ conIsRecord conName sp sl d m = showParen (d > 10) $ showString conName . showChar ' ' . showBraces conIsRecord (foldr (.) id (gliftShowsPrecAll opts conIsRecord sp sl 11 m))
@ -163,7 +163,7 @@ instance (GShow1Body f, GShow1Body g) => GShow1Body (f :*: g) where
      else foldr (.) id (intersperse (showString " ") (gliftShowsPrecAll opts conIsRecord sp sl 11 (a :*: b)))
    Infix _ prec -> showParen (d > prec) $ gliftShowsPrec opts sp sl (succ prec) a . showChar ' ' . showString conName . showChar ' ' . gliftShowsPrec opts sp sl (succ prec) b

-  gliftShowsPrecAll opts conIsRecord sp sl d (a :*: b) = gliftShowsPrecAll opts conIsRecord sp sl d a <> gliftShowsPrecAll opts conIsRecord sp sl d b
+  gliftShowsPrecAll opts conIsRecord sp sl d (a :*: b) = gliftShowsPrecAll opts conIsRecord sp sl d a <> gliftShowsPrecAll opts conIsRecord sp sl d b

 instance GShow1 f => GShow1 (M1 S c f) where
  gliftShowsPrec opts sp sl d (M1 a) = gliftShowsPrec opts sp sl d a
--- a/src/Diffing/Algorithm.hs
+++ b/src/Diffing/Algorithm.hs
@ -8,7 +8,7 @@ import Data.Term
 import Prologue

 -- | A single step in a diffing algorithm, parameterized by the types of terms, diffs, and the result of the applicable algorithm.
-data AlgorithmF term1 term2 result partial where
+data AlgorithmF term1 term2 result partial where
  -- | Diff two terms with the choice of algorithm left to the interpreter’s discretion.
  Diff :: term1 -> term2 -> AlgorithmF term1 term2 result result
  -- | Diff two terms recursively in O(n) time, resulting in a single diff node.
--- a/src/Language/Haskell/Assignment.hs
+++ b/src/Language/Haskell/Assignment.hs
@ -37,12 +37,18 @@ type Syntax = '[
  , Literal.TextElement
  , Literal.Tuple
  , Statement.If
+  , Statement.Match
+  , Statement.Pattern
  , Syntax.AllConstructors
  , Syntax.AnnotatedTypeVariable
  , Syntax.App
  , Syntax.ArithmeticSequence
+  , Syntax.AsPattern
  , Syntax.BindPattern
+  , Syntax.CaseGuardPattern
  , Syntax.Class
+  , Syntax.ConstructorIdentifier
+  , Syntax.ConstructorOperator
  , Syntax.ConstructorPattern
  , Syntax.ConstructorSymbol
  , Syntax.Context
@ -53,44 +59,70 @@ type Syntax = '[
  , Syntax.Deriving
  , Syntax.Do
  , Syntax.Empty
-  , Syntax.EntityIdentifier
  , Syntax.Error
  , Syntax.EqualityConstraint
  , Syntax.Export
+  , Syntax.ExpressionTypeSignature
  , Syntax.Field
+  , Syntax.FieldBind
+  , Syntax.FieldPattern
  , Syntax.Fixity'
  , Syntax.FunctionalDependency
  , Syntax.FunctionConstructor
+  , Syntax.FunctionGuardPattern
  , Syntax.FunctionType
  , Syntax.GADT
  , Syntax.GADTConstructor
  , Syntax.Generator
+  , Syntax.Guard
  , Syntax.HiddenImport
  , Syntax.Identifier
+  , Syntax.InfixConstructorIdentifier
+  , Syntax.InfixOperatorApp
+  , Syntax.InfixVariableIdentifier
+  , Syntax.ImplicitParameterIdentifier
  , Syntax.Import
  , Syntax.ImportAlias
  , Syntax.ImportDeclaration
+  , Syntax.InfixDataConstructor
  , Syntax.InfixOperatorPattern
  , Syntax.Instance
+  , Syntax.IrrefutablePattern
  , Syntax.Kind
  , Syntax.KindFunctionType
  , Syntax.KindListType
  , Syntax.KindParenthesizedConstructor
  , Syntax.KindSignature
  , Syntax.KindTupleType
+  , Syntax.LabeledConstruction
  , Syntax.LabeledPattern
+  , Syntax.LabeledUpdate
  , Syntax.Lambda
+  , Syntax.LambdaCase
+  , Syntax.LeftOperatorSection
+  , Syntax.Let
  , Syntax.ListComprehension
  , Syntax.ListConstructor
+  , Syntax.ListPattern
  , Syntax.Module
  , Syntax.ModuleExport
+  , Syntax.ModuleIdentifier
+  , Syntax.NamedFieldPun
+  , Syntax.NegativeLiteral
  , Syntax.NewType
-  , Syntax.Operator
-  , Syntax.OperatorSection
+  , Syntax.PatternGuard
  , Syntax.Pragma
  , Syntax.PrefixNegation
-  , Syntax.QualifiedEntityIdentifier
+  , Syntax.PrimitiveConstructorIdentifier
+  , Syntax.PrimitiveVariableIdentifier
+  , Syntax.PromotedTypeOperator
+  , Syntax.QualifiedConstructorIdentifier
+  , Syntax.QualifiedInfixVariableIdentifier
+  , Syntax.QualifiedModuleIdentifier
  , Syntax.QualifiedImportDeclaration
+  , Syntax.QualifiedTypeClassIdentifier
+  , Syntax.QualifiedTypeConstructorIdentifier
+  , Syntax.QualifiedVariableIdentifier
  , Syntax.QuasiQuotation
  , Syntax.QuasiQuotationDeclaration
  , Syntax.QuasiQuotationExpression
@ -101,26 +133,37 @@ type Syntax = '[
  , Syntax.QuotedName
  , Syntax.RecordDataConstructor
  , Syntax.RecordWildCards
+  , Syntax.RightOperatorSection
  , Syntax.ScopedTypeVariables
  , Syntax.Splice
  , Syntax.StandaloneDerivingInstance
  , Syntax.Star
+  , Syntax.StrictPattern
  , Syntax.StrictType
  , Syntax.StrictTypeVariable
  , Syntax.Tuple
  , Syntax.TupleConstructor
  , Syntax.TuplePattern
  , Syntax.Type
+  , Syntax.TypeApp
  , Syntax.TypeClass
+  , Syntax.TypeClassIdentifier
  , Syntax.TypeClassInstance
  , Syntax.TypeConstructorExport
+  , Syntax.TypeConstructorIdentifier
  , Syntax.TypeFamily
  , Syntax.TypeInstance
+  , Syntax.TypeOperator
  , Syntax.TypePattern
  , Syntax.TypeSignature
  , Syntax.TypeSynonym
+  , Syntax.TypeVariableIdentifier
  , Syntax.UnitConstructor
+  , Syntax.VariableIdentifier
+  , Syntax.VariableOperator
  , Syntax.VariableSymbol
+  , Syntax.ViewPattern
+  , Syntax.Wildcard
  , Type.TypeParameters
  , []
  ]
@ -138,18 +181,22 @@ algebraicDatatypeDeclaration = makeTerm
                            <*> children (Declaration.Datatype
                                        <$> (context' <|> emptyTerm)
                                        <*> (makeTerm <$> location <*> (Syntax.Type <$> typeConstructor <*> typeParameters <*> (kindSignature <|> emptyTerm)))
-                                        <*> ((symbol Constructors *> children (manyTerm constructor))
-                                            <|> pure [])
-                                        <*> (derivingClause <|> emptyTerm))
+                                        <*> (constructors <|> pure [])
+                                        <*> (term derivingClause <|> emptyTerm))
+  where
+    constructors = symbol Constructors *> children (manyTerm constructor)

 allConstructors :: Assignment
 allConstructors = makeTerm <$> token AllConstructors <*> pure Syntax.AllConstructors

+alternative :: Assignment
+alternative = makeTerm <$> symbol Alternative <*> children (Statement.Pattern <$> expression <*> expressions)
+
 annotatedTypeVariable :: Assignment
-annotatedTypeVariable = makeTerm <$> symbol AnnotatedTypeVariable <*> children (Syntax.AnnotatedTypeVariable <$> typeVariableIdentifier <* token Annotation <*> (kind <|> type'))
+annotatedTypeVariable = makeTerm <$> symbol AnnotatedTypeVariable <*> children (Syntax.AnnotatedTypeVariable <$> typeVariableIdentifier <* token Annotation <*> expression)

 app :: Assignment
-app = makeTerm <$> symbol FunctionApplication <*> children (Syntax.App <$> expression <*> expression)
+app = makeTerm <$> symbol FunctionApplication <*> children (Syntax.App <$> expression <*> (typeApp <|> emptyTerm) <*> expression)

 arithmeticSequence :: Assignment
 arithmeticSequence = symbol ArithmeticSequence *> children (  enumFrom
@ -157,13 +204,22 @@ arithmeticSequence = symbol ArithmeticSequence *> children (  enumFrom
                                                          <|> enumFromTo
                                                          <|> enumFromThenTo)
  where
-    enumFrom = makeTerm <$> symbol EnumFrom <*> children (Syntax.EnumFrom <$> expression)
-    enumFromThen = makeTerm <$> symbol EnumFromThen <*> children (Syntax.EnumFromThen <$> expression <*> expression)
-    enumFromTo = makeTerm <$> symbol EnumFromTo <*> children (Syntax.EnumFromTo <$> expression <*> expression)
-    enumFromThenTo = makeTerm <$> symbol EnumFromThenTo <*> children (Syntax.EnumFromThenTo <$> expression <*> expression <*> expression)
+    enumFrom = makeTerm <$> symbol EnumFrom <*> children (Syntax.ArithmeticSequence <$> expression <*> pure Nothing <*> pure Nothing)
+    enumFromThen = makeTerm <$> symbol EnumFromThen <*> children (Syntax.ArithmeticSequence <$> expression <*> (fmap Just expression) <*> pure Nothing)
+    enumFromTo = makeTerm <$> symbol EnumFromTo <*> children (Syntax.ArithmeticSequence <$> expression <*> (fmap Just expression) <*> pure Nothing)
+    enumFromThenTo = makeTerm <$> symbol EnumFromThenTo <*> children (Syntax.ArithmeticSequence <$> expression <*> (fmap Just expression) <*> (fmap Just expression))
+
+asPattern :: Assignment
+asPattern = makeTerm <$> symbol AsPattern <*> children (Syntax.AsPattern <$> expression <*> expression)

 bindPattern :: Assignment
-bindPattern = makeTerm <$> symbol BindPattern <*> children (Syntax.BindPattern <$> expression <*> expression)
+bindPattern = makeTerm <$> symbol BindPattern <*> children (Syntax.BindPattern <$> (manyTermsTill expression (symbol AnonLAngleMinus)) <*> expression)
+
+case' :: Assignment
+case' = makeTerm <$> symbol CaseExpression <*> children (Statement.Match <$> expression <*> expressions)
+
+caseGuardPattern :: Assignment
+caseGuardPattern = makeTerm <$> symbol CaseGuardPattern <*> children (Syntax.CaseGuardPattern <$> manyTerm expression)

 character :: Assignment
 character = makeTerm <$> symbol Char <*> (Literal.Character <$> source)
@ -179,7 +235,8 @@ conditionalExpression = makeTerm <$> symbol ConditionalExpression <*> children (

 constructor :: Assignment
 constructor =  (makeTerm <$> symbol DataConstructor <*> children (Declaration.Constructor <$> manyTerm (context' <|> scopedTypeVariables) <*> typeConstructor <*> typeParameters))
-           <|> (makeTerm <$> symbol RecordDataConstructor <*> children (Syntax.RecordDataConstructor <$> constructorIdentifier <*> fields))
+           <|> term (makeTerm <$> symbol RecordDataConstructor <*> children (Syntax.RecordDataConstructor <$> manyTerm (context' <|> scopedTypeVariables)  <*> constructorIdentifier <*> (term fields)))
+           <|> term (makeTerm <$> symbol InfixDataConstructor <*> children (Syntax.InfixDataConstructor <$> manyTerm (context' <|> scopedTypeVariables) <*> expression <*> expression <*> expression))

 constructorIdentifier :: Assignment
 constructorIdentifier = makeTerm <$> symbol ConstructorIdentifier <*> (Syntax.ConstructorIdentifier . Name.name <$> source)
@ -209,7 +266,7 @@ defaultSignature :: Assignment
 defaultSignature = makeTerm <$> symbol DefaultSignature <*> children (Syntax.DefaultSignature <$> manyTermsTill expression (symbol Annotation) <* token Annotation <*> manyTerm (context' <|> scopedTypeVariables) <*> expressions)

 derivingClause :: Assignment
-derivingClause = makeTerm <$> symbol Deriving <*> children (Syntax.Deriving <$> manyTerm typeConstructor)
+derivingClause = makeTerm <$> symbol Deriving <*> children (Syntax.Deriving <$> manyTerm expression)

 do' :: Assignment
 do' = makeTerm <$> symbol Do <*> children (Syntax.Do <$> manyTerm expression)
@ -224,7 +281,7 @@ export :: Assignment
 export = makeTerm <$> symbol Export <*> children (Syntax.Export <$> expressions)

 expression' :: Assignment
-expression' = symbol Expression *> children (expression <|> emptyTerm)
+expression' = symbol Expression *> children expressions

 expressions :: Assignment
 expressions = makeTerm'' <$> location <*> manyTerm expression
@ -236,11 +293,16 @@ expressionChoices :: [Assignment.Assignment [] Grammar Term]
 expressionChoices = [
                      algebraicDatatypeDeclaration
                    , allConstructors
+                    , alternative
                    , annotatedTypeVariable
                    , app
                    , arithmeticSequence
+                    , asPattern
                    , bindPattern
+                    , case'
+                    , caseGuardPattern
                    , character
+                    , class'
                    , comment
                    , conditionalExpression
                    , context'
@ -256,51 +318,72 @@ expressionChoices = [
                    , do'
                    , equalityConstraint
                    , expression'
+                    , expressionTypeSignature
+                    , fields
+                    , fieldBind
+                    , fieldPattern
                    , fixityDeclaration
                    , float
                    , functionalDependency
                    , functionConstructor
                    , functionDeclaration
+                    , functionGuardPattern
                    , functionType
                    , gadtConstructor
                    , gadtDeclaration
                    , generator
+                    , guard'
+                    , implicitParameterIdentifier
                    , importAlias
                    , importDeclaration
+                    , infixConstructorIdentifier
                    , infixOperatorApp
                    , infixOperatorPattern
                    , infixVariableIdentifier
                    , instance'
                    , integer
+                    , irrefutablePattern
                    , kind
                    , kindListType
                    , kindFunctionType
                    , kindParenthesizedConstructor
                    , kindSignature
                    , kindTupleType
+                    , labeledConstruction
                    , labeledPattern
+                    , labeledUpdate
                    , lambda
+                    , lambdaCase
+                    , letExpression
+                    , letStatement
                    , listConstructor
                    , listComprehension
                    , listExpression
+                    , listPattern
                    , listType
                    , moduleExport
                    , moduleIdentifier
+                    , namedFieldPun
+                    , negativeLiteral
                    , newType
                    , operator
                    , operatorSection
+                    , parenthesizedConstructorOperator
                    , parenthesizedExpression
                    , parenthesizedPattern
                    , parenthesizedTypePattern
                    , pattern'
+                    , patternGuard
                    , pragma
                    , prefixNegation
                    , primitiveConstructorIdentifier
                    , primitiveVariableIdentifier
+                    , promotedTypeOperator
                    , qualifiedConstructorIdentifier
                    , qualifiedImportDeclaration
                    , qualifiedInfixVariableIdentifier
                    , qualifiedModuleIdentifier
+                    , qualifiedTypeClassIdentifier
                    , qualifiedTypeConstructorIdentifier
                    , qualifiedVariableIdentifier
                    , quasiQuotation
@ -316,6 +399,7 @@ expressionChoices = [
                    , splice
                    , standaloneDerivingInstance
                    , star
+                    , strictPattern
                    , strictType
                    , string
                    , tuple
@ -323,9 +407,11 @@ expressionChoices = [
                    , tupleType
                    , type'
                    , type''
+                    , typeApp
                    , typeClass
                    , typeClassIdentifier
                    , typeClassInstance
+                    , typeConstructor
                    , typeFamily
                    , typeInstance
                    , typePattern
@ -340,9 +426,14 @@ expressionChoices = [
                    , variableIdentifier
                    , variableOperator
                    , variableSymbol
+                    , viewPattern
                    , where'
+                    , wildcard
                    ]

+expressionTypeSignature :: Assignment
+expressionTypeSignature = makeTerm <$> symbol ExpressionTypeSignature <*> children (Syntax.ExpressionTypeSignature <$> manyTermsTill expression (symbol Annotation) <* token Annotation <*> manyTerm (context' <|> scopedTypeVariables) <*> expressions)
+
 fields :: Assignment
 fields = makeTerm <$> symbol Fields <*> children (manyTerm field)

@ -356,6 +447,12 @@ field = makeTerm
  where
    fieldType = makeTerm <$> location <*> (Syntax.Type <$> term (type' <|> typeVariableIdentifier) <*> typeParameters <*> (kindSignature <|> emptyTerm))

+fieldBind :: Assignment
+fieldBind = makeTerm <$> symbol FieldBind <*> children (Syntax.FieldBind <$> expression <*> expression)
+
+fieldPattern :: Assignment
+fieldPattern = makeTerm <$> symbol FieldPattern <*> children (Syntax.FieldPattern <$> expression <*> expressions)
+
 fixityDeclaration :: Assignment
 fixityDeclaration = makeTerm <$> symbol FixityDeclaration <*> children (Syntax.Fixity' <$> (integer <|> emptyTerm) <*> manyTerm expression)

@ -375,21 +472,24 @@ functionDeclaration :: Assignment
 functionDeclaration = makeTerm
                   <$> symbol FunctionDeclaration
                   <*> children (Declaration.Function []
-                               <$> expression
+                               <$> term expression
                               <*> (manyTermsTill expression (symbol FunctionBody) <|> pure [])
                               <*> functionBody)

+functionGuardPattern :: Assignment
+functionGuardPattern = makeTerm <$> symbol FunctionGuardPattern <*> children (Syntax.FunctionGuardPattern <$> manyTerm expression)
+
 functionType :: Assignment
-functionType = makeTerm <$> symbol FunctionType <*> children (Syntax.FunctionType <$> type' <*> type')
+functionType = makeTerm <$> symbol FunctionType <*> children (Syntax.FunctionType <$> expression <*> expression)

 gadtConstructor :: Assignment
 gadtConstructor = makeTerm
               <$> symbol GadtConstructor
               <*> children (Syntax.GADTConstructor
                           <$> (context' <|> emptyTerm)
-                           <*> typeConstructor
+                           <*> expression
                           <* token Annotation
-                           <*> term type')
+                           <*> expressions)

 gadtDeclaration :: Assignment
 gadtDeclaration = makeTerm
@ -404,12 +504,18 @@ gadtDeclaration = makeTerm
 generator :: Assignment
 generator = makeTerm <$> symbol Generator <*> children (Syntax.Generator <$> expression <*> expression)

+guard' :: Assignment
+guard' = makeTerm <$> symbol Guard <*> children (Syntax.Guard <$> expressions)
+
 hiddenImport :: Assignment
 hiddenImport = makeTerm <$> symbol Import <*> children (Syntax.HiddenImport <$> expressions)

 hiddenImportSpec :: Assignment.Assignment [] Grammar [Term]
 hiddenImportSpec = symbol HiddenImportSpec *> children (manyTerm hiddenImport)

+implicitParameterIdentifier :: Assignment
+implicitParameterIdentifier = makeTerm <$> symbol ImplicitParameterIdentifier <*> (Syntax.ImplicitParameterIdentifier . Name.name <$> source)
+
 import' :: Assignment
 import' = makeTerm <$> symbol Import <*> children (Syntax.Import <$> expressions)

@ -427,8 +533,14 @@ importDeclaration = makeTerm
 importSpec :: Assignment.Assignment [] Grammar [Term]
 importSpec = symbol ImportSpec *> children (manyTerm import')

+inClause :: Assignment
+inClause = symbol InClause *> children expressions
+
+infixConstructorIdentifier :: Assignment
+infixConstructorIdentifier = makeTerm <$> symbol InfixConstructorIdentifier <*> children (Syntax.InfixConstructorIdentifier . Name.name <$> source)
+
 infixOperatorApp :: Assignment
-infixOperatorApp = makeTerm <$> symbol InfixOperatorApplication <*> children (Syntax.InfixOperatorApp <$> expression <*> expression <*> expression)
+infixOperatorApp = makeTerm <$> symbol InfixOperatorApplication <*> children (Syntax.InfixOperatorApp <$> expression <*> (typeApp <|> emptyTerm) <*> expression <*> (expressions <|> emptyTerm))

 infixOperatorPattern :: Assignment
 infixOperatorPattern = makeTerm <$> symbol InfixOperatorPattern <*> children (Syntax.InfixOperatorPattern <$> expression <*> operator <*> expression)
@ -442,6 +554,9 @@ instance' = makeTerm <$> symbol Instance <*> children (Syntax.Instance <$> expre
 integer :: Assignment
 integer = makeTerm <$> symbol Integer <*> (Literal.Integer <$> source)

+irrefutablePattern :: Assignment
+irrefutablePattern = makeTerm <$> symbol IrrefutablePattern <*> children (Syntax.IrrefutablePattern <$> expression)
+
 kind :: Assignment
 kind = kind'
    <|> kindFunctionType
@ -469,15 +584,30 @@ kindSignature = makeTerm <$> symbol KindSignature <*> children (Syntax.KindSigna
 kindTupleType :: Assignment
 kindTupleType = makeTerm <$> symbol KindTupleType <*> children (Syntax.KindTupleType <$> manyTerm expression)

+labeledConstruction :: Assignment
+labeledConstruction = makeTerm <$> symbol LabeledConstruction <*> children (Syntax.LabeledConstruction <$> expression <*> manyTerm expression)
+
 labeledPattern :: Assignment
 labeledPattern = makeTerm <$> symbol LabeledPattern <*> children (Syntax.LabeledPattern <$> expressions)

+labeledUpdate :: Assignment
+labeledUpdate = makeTerm <$> symbol LabeledUpdate <*> children (Syntax.LabeledUpdate <$> manyTerm expression)
+
 lambda :: Assignment
 lambda = makeTerm <$> symbol Lambda <*> children (Syntax.Lambda <$> lambdaHead <*> lambdaBody)
  where
    lambdaHead = symbol LambdaHead *> children expressions
    lambdaBody = symbol LambdaBody *> children expressions

+lambdaCase :: Assignment
+lambdaCase = makeTerm <$> symbol LambdaCase <*> children (Syntax.LambdaCase <$> manyTerm expression)
+
+letExpression :: Assignment
+letExpression = makeTerm <$> symbol LetExpression <*> children (Syntax.Let <$> manyTermsTill expression (symbol InClause) <*> inClause)
+
+letStatement :: Assignment
+letStatement = makeTerm <$> symbol LetStatement <*> children (Syntax.Let <$> manyTerm expression <*> emptyTerm)
+
 listComprehension :: Assignment
 listComprehension = makeTerm <$> symbol ListComprehension <*> children (Syntax.ListComprehension <$> expression <*> manyTerm expression)

@ -488,19 +618,23 @@ listExpression :: Assignment
 listExpression = makeTerm <$> symbol ListExpression <*> children (Literal.Array <$> manyTerm listElement)
  where listElement = symbol Expression *> children expression

+listPattern :: Assignment
+listPattern = makeTerm <$> symbol ListPattern <*> children (Syntax.ListPattern <$> expressions)
+
 listType :: Assignment
 listType = makeTerm <$> symbol ListType <*> children (Literal.Array <$> manyTerm type')

 module' :: Assignment
-module' = makeTerm
+module' =  makeTerm
       <$> symbol Module
       <*> children (Syntax.Module
-                   <$> (term moduleIdentifier <|> emptyTerm)
+                   <$> manyTerm (comment <|> pragma)
+                   <*> term (moduleIdentifier <|> qualifiedModuleIdentifier <|> emptyTerm)
                   <*> moduleExports
-                   <*> (where' <|> expressions <|> emptyTerm))
+                   <*> term (where' <|> expressions <|> emptyTerm))
  where
-    moduleExports = symbol ModuleExports *> children (manyTerm export)
-                 <|> pure []
+    moduleExports = (symbol ModuleExports *> children (manyTerm export))
+                 <|> (pure [])

 moduleExport :: Assignment
 moduleExport = makeTerm <$> symbol ModuleExport <*> children (Syntax.ModuleExport <$> expressions)
@ -508,8 +642,14 @@ moduleExport = makeTerm <$> symbol ModuleExport <*> children (Syntax.ModuleExpor
 moduleIdentifier :: Assignment
 moduleIdentifier = makeTerm <$> symbol ModuleIdentifier <*> (Syntax.ModuleIdentifier . Name.name <$> source)

+namedFieldPun :: Assignment
+namedFieldPun = makeTerm <$> symbol NamedFieldPun <*> children (Syntax.NamedFieldPun <$> expression)
+
+negativeLiteral :: Assignment
+negativeLiteral = makeTerm <$> symbol NegativeLiteral <*> children (Syntax.NegativeLiteral <$> expression)
+
 newConstructor :: Assignment
-newConstructor = makeTerm <$> symbol NewConstructor <*> children (Declaration.Constructor <$> manyTerm (context' <|> scopedTypeVariables) <*> typeConstructor <*> typeParameters)
+newConstructor = makeTerm <$> symbol NewConstructor <*> children (Declaration.Constructor <$> manyTerm (context' <|> scopedTypeVariables) <*> expression <*> expressions)

 newType :: Assignment
 newType = makeTerm <$> symbol NewtypeDeclaration <*> children (Syntax.NewType <$> manyTerm (context' <|> scopedTypeVariables) <*> typeLeft <*> newConstructor <*> (derivingClause <|> emptyTerm))
@ -517,7 +657,10 @@ newType = makeTerm <$> symbol NewtypeDeclaration <*> children (Syntax.NewType <$
    typeLeft = makeTerm <$> location <*> manyTermsTill expression (symbol NewConstructor)

 operator :: Assignment
-operator = typeOperator <|> constructorOperator <|> variableOperator
+operator =  constructorOperator
+        <|> typeOperator
+        <|> promotedTypeOperator
+        <|> variableOperator

 operatorSection :: Assignment
 operatorSection = (makeTerm <$> symbol RightOperatorSection <*> children (Syntax.RightOperatorSection <$> expression <*> expression))
@ -526,8 +669,11 @@ operatorSection = (makeTerm <$> symbol RightOperatorSection <*> children (Syntax
 packageQualifiedImport :: Assignment
 packageQualifiedImport = makeTerm <$> symbol PackageQualifiedImport <*> (Literal.TextElement <$> source)

+parenthesizedConstructorOperator :: Assignment
+parenthesizedConstructorOperator = symbol ParenthesizedConstructorOperator *> children expression
+
 parenthesizedExpression :: Assignment
-parenthesizedExpression = symbol ParenthesizedExpression *> children expression
+parenthesizedExpression = symbol ParenthesizedExpression *> children expressions

 parenthesizedPattern :: Assignment
 parenthesizedPattern = symbol ParenthesizedPattern *> children expressions
@ -536,7 +682,10 @@ parenthesizedTypePattern :: Assignment
 parenthesizedTypePattern = symbol ParenthesizedTypePattern *> children expressions

 pattern' :: Assignment
-pattern' = symbol Pattern *> children expression
+pattern' = symbol Pattern *> children expressions
+
+patternGuard :: Assignment
+patternGuard = makeTerm <$> symbol PatternGuard <*> children (Syntax.PatternGuard <$> expression <*> (expression <|> emptyTerm))

 pragma :: Assignment
 pragma = makeTerm <$> symbol Pragma <*> (Syntax.Pragma <$> source)
@ -550,6 +699,9 @@ primitiveConstructorIdentifier = makeTerm <$> symbol PrimitiveConstructorIdentif
 primitiveVariableIdentifier :: Assignment
 primitiveVariableIdentifier = makeTerm <$> symbol PrimitiveVariableIdentifier <*> (Syntax.PrimitiveVariableIdentifier . Name.name <$> source)

+promotedTypeOperator :: Assignment
+promotedTypeOperator = makeTerm <$> symbol PromotedTypeOperator <*> children (Syntax.PromotedTypeOperator <$> expression)
+
 qualifiedConstructorIdentifier :: Assignment
 qualifiedConstructorIdentifier = makeTerm <$> symbol QualifiedConstructorIdentifier <*> children (Syntax.QualifiedConstructorIdentifier <$> someTerm' expression)

@ -567,6 +719,9 @@ qualifiedInfixVariableIdentifier = makeTerm <$> symbol QualifiedInfixVariableIde
 qualifiedModuleIdentifier :: Assignment
 qualifiedModuleIdentifier = makeTerm <$> symbol QualifiedModuleIdentifier <*> children (Syntax.QualifiedModuleIdentifier <$> someTerm' expression)

+qualifiedTypeClassIdentifier :: Assignment
+qualifiedTypeClassIdentifier = makeTerm <$> symbol QualifiedTypeClassIdentifier <*> children (Syntax.QualifiedTypeClassIdentifier <$> someTerm' expression)
+
 qualifiedTypeConstructorIdentifier :: Assignment
 qualifiedTypeConstructorIdentifier = makeTerm <$> symbol QualifiedTypeConstructorIdentifier <*> children (Syntax.QualifiedTypeConstructorIdentifier <$> someTerm' expression)

@ -614,6 +769,9 @@ standaloneDerivingInstance = makeTerm <$> symbol StandaloneDerivingDeclaration <
 star :: Assignment
 star = makeTerm <$> token Star <*> pure Syntax.Star

+strictPattern :: Assignment
+strictPattern = makeTerm <$> symbol StrictPattern <*> children (Syntax.StrictPattern <$> expression)
+
 strictType :: Assignment
 strictType = makeTerm'
          <$> symbol StrictType
@ -630,7 +788,7 @@ tuplePattern :: Assignment
 tuplePattern = makeTerm <$> symbol TuplePattern <*> children (Syntax.TuplePattern <$> manyTerm expression)

 tupleType :: Assignment
-tupleType = makeTerm <$> symbol TupleType <*> children (Literal.Tuple <$> manyTerm type')
+tupleType = makeTerm <$> symbol TupleType <*> children (Literal.Tuple <$> manyTerm expression)

 tuplingConstructor :: Assignment
 tuplingConstructor = makeTerm <$> symbol TuplingConstructor <*> (tupleWithArity <$> rawSource)
@ -652,6 +810,9 @@ type'' = makeTerm
      <$> symbol Type
      <*> children (Syntax.Type <$> expression <*> typeParameters <*> (kindSignature <|> emptyTerm))

+typeApp :: Assignment
+typeApp = makeTerm <$> symbol TypeApplication <*> children (Syntax.TypeApp <$> expression)
+
 typeClass :: Assignment
 typeClass = makeTerm <$> symbol TypeClassDeclaration <*> children (Syntax.TypeClass
                                                                 <$> (context' <|> emptyTerm)
@ -675,6 +836,7 @@ typeConstructor =  constructorIdentifier
               <|> listConstructor
               <|> listType
               <|> qualifiedModuleIdentifier
+               <|> qualifiedTypeClassIdentifier
               <|> qualifiedTypeConstructorIdentifier
               <|> quotedName
               <|> tupleType
@ -746,9 +908,15 @@ variableSymbol = makeTerm <$> (symbol VariableSymbol <|> symbol VariableSymbol')
 variableIdentifiers :: Assignment
 variableIdentifiers = makeTerm <$> location <*> many variableIdentifier

+viewPattern :: Assignment
+viewPattern = makeTerm <$> symbol ViewPattern <*> children (Syntax.ViewPattern <$> expression <*> expression)
+
 where' :: Assignment
 where' = makeTerm <$> (symbol Where <|> symbol Where') <*> children (manyTerm expression)

+wildcard :: Assignment
+wildcard = makeTerm <$> token Wildcard <*> pure Syntax.Wildcard
+
 -- | Helpers

 commentedTerm :: Assignment -> Assignment
--- a/src/Language/Haskell/Syntax.hs
+++ b/src/Language/Haskell/Syntax.hs
@ -7,9 +7,10 @@ import           Diffing.Algorithm
 import           Prelude
 import           Prologue

-data Module a = Module { moduleIdentifier :: !a
-                       , moduleExports    :: ![a]
-                       , moduleStatements :: !a
+data Module a = Module { moduleContext    :: [a]
+                       , moduleIdentifier :: a
+                       , moduleExports    :: [a]
+                       , moduleStatements :: a
                       }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

@ -19,7 +20,16 @@ instance Show1 Module where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable Module

-data StrictType a = StrictType { strictTypeIdentifier :: !a, strictTypeParameters :: !a }
+newtype StrictPattern a = StrictPattern a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 StrictPattern where liftEq = genericLiftEq
+instance Ord1 StrictPattern where liftCompare = genericLiftCompare
+instance Show1 StrictPattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable StrictPattern
+
+data StrictType a = StrictType { strictTypeIdentifier :: a, strictTypeParameters :: a }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

 instance Eq1 StrictType where liftEq = genericLiftEq
@ -28,7 +38,7 @@ instance Show1 StrictType where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable StrictType

-newtype StrictTypeVariable a = StrictTypeVariable { strictTypeVariableIdentifier :: a }
+newtype StrictTypeVariable a = StrictTypeVariable a
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

 instance Eq1 StrictTypeVariable where liftEq = genericLiftEq
@ -91,7 +101,7 @@ instance Show1 FunctionConstructor where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable FunctionConstructor

-data RecordDataConstructor a = RecordDataConstructor { recordDataConstructorName :: !a, recordDataConstructorFields :: !a }
+data RecordDataConstructor a = RecordDataConstructor { recordDataConstructorContext :: [a], recordDataConstructorName :: !a, recordDataConstructorFields :: !a }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

 instance Eq1 RecordDataConstructor where liftEq = genericLiftEq
@ -180,6 +190,15 @@ instance Show1 TypeSignature where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable TypeSignature

+data ExpressionTypeSignature a = ExpressionTypeSignature { expressionTypeSignatureName :: [a], expressionTypeSignatureContext :: [a], expressionTypeSignatureContent :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 ExpressionTypeSignature where liftEq = genericLiftEq
+instance Ord1 ExpressionTypeSignature where liftCompare = genericLiftCompare
+instance Show1 ExpressionTypeSignature where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable ExpressionTypeSignature
+
 newtype KindSignature a = KindSignature { kindSignatureContent :: a }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

@ -225,19 +244,65 @@ instance Show1 Star where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable Star

-data QualifiedEntityIdentifier a = QualifiedTypeConstructorIdentifier (NonEmpty a)
-                                 | QualifiedConstructorIdentifier (NonEmpty a)
-                                 | QualifiedInfixVariableIdentifier (NonEmpty a)
-                                 | QualifiedModuleIdentifier (NonEmpty a)
-                                 | QualifiedVariableIdentifier (NonEmpty a)
+data QualifiedTypeClassIdentifier a = QualifiedTypeClassIdentifier (NonEmpty a)
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

-instance Eq1 QualifiedEntityIdentifier where liftEq = genericLiftEq
-instance Ord1 QualifiedEntityIdentifier where liftCompare = genericLiftCompare
-instance Show1 QualifiedEntityIdentifier where liftShowsPrec = genericLiftShowsPrec
-instance Hashable1 QualifiedEntityIdentifier where liftHashWithSalt = foldl
+instance Eq1 QualifiedTypeClassIdentifier where liftEq = genericLiftEq
+instance Ord1 QualifiedTypeClassIdentifier where liftCompare = genericLiftCompare
+instance Show1 QualifiedTypeClassIdentifier where liftShowsPrec = genericLiftShowsPrec
+instance Hashable1 QualifiedTypeClassIdentifier where liftHashWithSalt = foldl

-instance Evaluatable QualifiedEntityIdentifier
+instance Evaluatable QualifiedTypeClassIdentifier
+
+newtype QualifiedTypeConstructorIdentifier a = QualifiedTypeConstructorIdentifier (NonEmpty a)
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 QualifiedTypeConstructorIdentifier where liftEq = genericLiftEq
+instance Ord1 QualifiedTypeConstructorIdentifier where liftCompare = genericLiftCompare
+instance Show1 QualifiedTypeConstructorIdentifier where liftShowsPrec = genericLiftShowsPrec
+instance Hashable1 QualifiedTypeConstructorIdentifier where liftHashWithSalt = foldl
+
+instance Evaluatable QualifiedTypeConstructorIdentifier
+
+newtype QualifiedConstructorIdentifier a = QualifiedConstructorIdentifier (NonEmpty a)
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 QualifiedConstructorIdentifier where liftEq = genericLiftEq
+instance Ord1 QualifiedConstructorIdentifier where liftCompare = genericLiftCompare
+instance Show1 QualifiedConstructorIdentifier where liftShowsPrec = genericLiftShowsPrec
+instance Hashable1 QualifiedConstructorIdentifier where liftHashWithSalt = foldl
+
+instance Evaluatable QualifiedConstructorIdentifier
+
+newtype QualifiedInfixVariableIdentifier a = QualifiedInfixVariableIdentifier (NonEmpty a)
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 QualifiedInfixVariableIdentifier where liftEq = genericLiftEq
+instance Ord1 QualifiedInfixVariableIdentifier where liftCompare = genericLiftCompare
+instance Show1 QualifiedInfixVariableIdentifier where liftShowsPrec = genericLiftShowsPrec
+instance Hashable1 QualifiedInfixVariableIdentifier where liftHashWithSalt = foldl
+
+instance Evaluatable QualifiedInfixVariableIdentifier
+
+newtype QualifiedModuleIdentifier a = QualifiedModuleIdentifier (NonEmpty a)
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 QualifiedModuleIdentifier where liftEq = genericLiftEq
+instance Ord1 QualifiedModuleIdentifier where liftCompare = genericLiftCompare
+instance Show1 QualifiedModuleIdentifier where liftShowsPrec = genericLiftShowsPrec
+instance Hashable1 QualifiedModuleIdentifier where liftHashWithSalt = foldl
+
+instance Evaluatable QualifiedModuleIdentifier
+
+newtype QualifiedVariableIdentifier a = QualifiedVariableIdentifier (NonEmpty a)
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 QualifiedVariableIdentifier where liftEq = genericLiftEq
+instance Ord1 QualifiedVariableIdentifier where liftCompare = genericLiftCompare
+instance Show1 QualifiedVariableIdentifier where liftShowsPrec = genericLiftShowsPrec
+instance Hashable1 QualifiedVariableIdentifier where liftHashWithSalt = foldl
+
+instance Evaluatable QualifiedVariableIdentifier

 data AnnotatedTypeVariable a = AnnotatedTypeVariable { annotatedTypeVariableIdentifier :: a, annotatedTypeVariableannotation :: a }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
@ -347,33 +412,140 @@ instance Show1 EqualityConstraint where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable EqualityConstraint

-data EntityIdentifier a = TypeVariableIdentifier Name
-                        | TypeConstructorIdentifier Name
-                        | ModuleIdentifier Name
-                        | ConstructorIdentifier Name
-                        | InfixVariableIdentifier Name
-                        | TypeClassIdentifier Name
-                        | VariableIdentifier Name
-                        | PrimitiveConstructorIdentifier Name
-                        | PrimitiveVariableIdentifier Name
+newtype TypeVariableIdentifier a = TypeVariableIdentifier Name
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

-instance Eq1 EntityIdentifier where liftEq = genericLiftEq
-instance Ord1 EntityIdentifier where liftCompare = genericLiftCompare
-instance Show1 EntityIdentifier where liftShowsPrec = genericLiftShowsPrec
+instance Eq1 TypeVariableIdentifier where liftEq = genericLiftEq
+instance Ord1 TypeVariableIdentifier where liftCompare = genericLiftCompare
+instance Show1 TypeVariableIdentifier where liftShowsPrec = genericLiftShowsPrec

-instance Evaluatable EntityIdentifier
+instance Evaluatable TypeVariableIdentifier

-data Operator a = VariableOperator a
-                | ConstructorOperator a
-                | TypeOperator Name
+newtype TypeConstructorIdentifier a = TypeConstructorIdentifier Name
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

-instance Eq1 Operator where liftEq = genericLiftEq
-instance Ord1 Operator where liftCompare = genericLiftCompare
-instance Show1 Operator where liftShowsPrec = genericLiftShowsPrec
+instance Eq1 TypeConstructorIdentifier where liftEq = genericLiftEq
+instance Ord1 TypeConstructorIdentifier where liftCompare = genericLiftCompare
+instance Show1 TypeConstructorIdentifier where liftShowsPrec = genericLiftShowsPrec

-instance Evaluatable Operator
+instance Evaluatable TypeConstructorIdentifier
+
+newtype ModuleIdentifier a = ModuleIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 ModuleIdentifier where liftEq = genericLiftEq
+instance Ord1 ModuleIdentifier where liftCompare = genericLiftCompare
+instance Show1 ModuleIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable ModuleIdentifier
+
+newtype ConstructorIdentifier a = ConstructorIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 ConstructorIdentifier where liftEq = genericLiftEq
+instance Ord1 ConstructorIdentifier where liftCompare = genericLiftCompare
+instance Show1 ConstructorIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable ConstructorIdentifier
+
+newtype ImplicitParameterIdentifier a = ImplicitParameterIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 ImplicitParameterIdentifier where liftEq = genericLiftEq
+instance Ord1 ImplicitParameterIdentifier where liftCompare = genericLiftCompare
+instance Show1 ImplicitParameterIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable ImplicitParameterIdentifier
+
+newtype InfixConstructorIdentifier a = InfixConstructorIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 InfixConstructorIdentifier where liftEq = genericLiftEq
+instance Ord1 InfixConstructorIdentifier where liftCompare = genericLiftCompare
+instance Show1 InfixConstructorIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable InfixConstructorIdentifier
+
+newtype InfixVariableIdentifier a = InfixVariableIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 InfixVariableIdentifier where liftEq = genericLiftEq
+instance Ord1 InfixVariableIdentifier where liftCompare = genericLiftCompare
+instance Show1 InfixVariableIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable InfixVariableIdentifier
+
+newtype TypeClassIdentifier a = TypeClassIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 TypeClassIdentifier where liftEq = genericLiftEq
+instance Ord1 TypeClassIdentifier where liftCompare = genericLiftCompare
+instance Show1 TypeClassIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable TypeClassIdentifier
+
+newtype VariableIdentifier a = VariableIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 VariableIdentifier where liftEq = genericLiftEq
+instance Ord1 VariableIdentifier where liftCompare = genericLiftCompare
+instance Show1 VariableIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable VariableIdentifier
+
+newtype PrimitiveConstructorIdentifier a = PrimitiveConstructorIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 PrimitiveConstructorIdentifier where liftEq = genericLiftEq
+instance Ord1 PrimitiveConstructorIdentifier where liftCompare = genericLiftCompare
+instance Show1 PrimitiveConstructorIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable PrimitiveConstructorIdentifier
+
+newtype PrimitiveVariableIdentifier a = PrimitiveVariableIdentifier Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 PrimitiveVariableIdentifier where liftEq = genericLiftEq
+instance Ord1 PrimitiveVariableIdentifier where liftCompare = genericLiftCompare
+instance Show1 PrimitiveVariableIdentifier where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable PrimitiveVariableIdentifier
+
+newtype VariableOperator a = VariableOperator a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 VariableOperator where liftEq = genericLiftEq
+instance Ord1 VariableOperator where liftCompare = genericLiftCompare
+instance Show1 VariableOperator where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable VariableOperator
+
+newtype ConstructorOperator a = ConstructorOperator a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 ConstructorOperator where liftEq = genericLiftEq
+instance Ord1 ConstructorOperator where liftCompare = genericLiftCompare
+instance Show1 ConstructorOperator where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable ConstructorOperator
+
+newtype TypeOperator a = TypeOperator Name
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 TypeOperator where liftEq = genericLiftEq
+instance Ord1 TypeOperator where liftCompare = genericLiftCompare
+instance Show1 TypeOperator where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable TypeOperator
+
+newtype PromotedTypeOperator a = PromotedTypeOperator a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 PromotedTypeOperator where liftEq = genericLiftEq
+instance Ord1 PromotedTypeOperator where liftCompare = genericLiftCompare
+instance Show1 PromotedTypeOperator where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable PromotedTypeOperator

 newtype ConstructorSymbol a = ConstructorSymbol { constructorSymbolName :: Name }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
@ -447,8 +619,7 @@ instance Show1 ImportAlias where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable ImportAlias

-data App a = App { appLeft :: a, appRight :: a }
-           | InfixOperatorApp { appLeft :: a, infixOperator :: a, appRight :: a }
+data App a = App { appLeft :: a, appLeftTypeApp :: a, appRight :: a }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

 instance Eq1 App where liftEq = genericLiftEq
@ -457,6 +628,24 @@ instance Show1 App where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable App

+data InfixOperatorApp a = InfixOperatorApp { infixOperatorAppLeft :: a, infixOperatorAppLeftTypeApp :: a, infixOperatorAppOperator :: a, infixOperatorAppRight :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 InfixOperatorApp where liftEq = genericLiftEq
+instance Ord1 InfixOperatorApp where liftCompare = genericLiftCompare
+instance Show1 InfixOperatorApp where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable InfixOperatorApp
+
+newtype TypeApp a = TypeApp { typeAppType :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 TypeApp where liftEq = genericLiftEq
+instance Ord1 TypeApp where liftCompare = genericLiftCompare
+instance Show1 TypeApp where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable TypeApp
+
 data ListComprehension a = ListComprehension { comprehensionValue :: a, comprehensionSource :: [a] }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

@ -493,10 +682,8 @@ instance Show1 TuplePattern where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable TuplePattern

-data ArithmeticSequence a = EnumFrom a            -- e.g. [1..]
-                          | EnumFromThen a a      -- e.g. [1,2..]
-                          | EnumFromTo a a        -- e.g. [1..2]
-                          | EnumFromThenTo a a a  -- e.g. [1,2..10]
+-- e.g. [1..], [1,2..], [1,2..10]
+data ArithmeticSequence a = ArithmeticSequence { from :: a, next :: Maybe a, to :: Maybe a  }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

 instance Eq1 ArithmeticSequence where liftEq = genericLiftEq
@ -505,15 +692,23 @@ instance Show1 ArithmeticSequence where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable ArithmeticSequence

-data OperatorSection a = RightOperatorSection a a
-                       | LeftOperatorSection a a
+data RightOperatorSection a = RightOperatorSection a a
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

-instance Eq1 OperatorSection where liftEq = genericLiftEq
-instance Ord1 OperatorSection where liftCompare = genericLiftCompare
-instance Show1 OperatorSection where liftShowsPrec = genericLiftShowsPrec
+instance Eq1 RightOperatorSection where liftEq = genericLiftEq
+instance Ord1 RightOperatorSection where liftCompare = genericLiftCompare
+instance Show1 RightOperatorSection where liftShowsPrec = genericLiftShowsPrec

-instance Evaluatable OperatorSection
+instance Evaluatable RightOperatorSection
+
+data LeftOperatorSection a = LeftOperatorSection a a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 LeftOperatorSection where liftEq = genericLiftEq
+instance Ord1 LeftOperatorSection where liftCompare = genericLiftCompare
+instance Show1 LeftOperatorSection where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable LeftOperatorSection

 newtype ConstructorPattern a = ConstructorPattern a
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
@ -525,7 +720,7 @@ instance Show1 ConstructorPattern where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ConstructorPattern

 -- e.g. `a <- b` in a Haskell do block.
-data BindPattern a = BindPattern { bindPatternLeft :: a, bindPatternRight :: a }
+data BindPattern a = BindPattern { bindPatternLeft :: [a], bindPatternRight :: a }
  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)

 instance Eq1 BindPattern where liftEq = genericLiftEq
@ -754,3 +949,175 @@ instance Ord1 KindTupleType where liftCompare = genericLiftCompare
 instance Show1 KindTupleType where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable KindTupleType
+
+data Wildcard a = Wildcard
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 Wildcard where liftEq = genericLiftEq
+instance Ord1 Wildcard where liftCompare = genericLiftCompare
+instance Show1 Wildcard where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable Wildcard
+
+data Let a = Let { letStatements :: [a], letInClause :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 Let where liftEq = genericLiftEq
+instance Ord1 Let where liftCompare = genericLiftCompare
+instance Show1 Let where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable Let
+
+newtype ListPattern a = ListPattern a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 ListPattern where liftEq = genericLiftEq
+instance Ord1 ListPattern where liftCompare = genericLiftCompare
+instance Show1 ListPattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable ListPattern
+
+-- e.g. The `n@num1` in `f n@num1 x@num2 = x`
+data AsPattern a = AsPattern { asPatternLeft :: a, asPatternRight :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 AsPattern where liftEq = genericLiftEq
+instance Ord1 AsPattern where liftCompare = genericLiftCompare
+instance Show1 AsPattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable AsPattern
+
+-- e.g. The `a = 1` in `foo Bar{ a = 1 } = baz`.
+data FieldPattern a = FieldPattern { fieldPatternLeft :: a, fieldPatternRight :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 FieldPattern where liftEq = genericLiftEq
+instance Ord1 FieldPattern where liftCompare = genericLiftCompare
+instance Show1 FieldPattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable FieldPattern
+
+-- e.g. The `start` or `end` in `f Blob{start, end} = [start, end]`.
+newtype NamedFieldPun a = NamedFieldPun a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 NamedFieldPun where liftEq = genericLiftEq
+instance Ord1 NamedFieldPun where liftCompare = genericLiftCompare
+instance Show1 NamedFieldPun where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable NamedFieldPun
+
+-- e.g. The `-(1)` in `f (-(1)) = 1`.
+newtype NegativeLiteral a = NegativeLiteral a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 NegativeLiteral where liftEq = genericLiftEq
+instance Ord1 NegativeLiteral where liftCompare = genericLiftCompare
+instance Show1 NegativeLiteral where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable NegativeLiteral
+
+-- e.g. The `~a` in `f ~a = 1`
+newtype IrrefutablePattern a = IrrefutablePattern a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 IrrefutablePattern where liftEq = genericLiftEq
+instance Ord1 IrrefutablePattern where liftCompare = genericLiftCompare
+instance Show1 IrrefutablePattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable IrrefutablePattern
+
+-- For handling guards in case alternative expressions.
+newtype CaseGuardPattern a = CaseGuardPattern [a]
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 CaseGuardPattern where liftEq = genericLiftEq
+instance Ord1 CaseGuardPattern where liftCompare = genericLiftCompare
+instance Show1 CaseGuardPattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable CaseGuardPattern
+
+newtype Guard a = Guard a
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 Guard where liftEq = genericLiftEq
+instance Ord1 Guard where liftCompare = genericLiftCompare
+instance Show1 Guard where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable Guard
+
+newtype LambdaCase a = LambdaCase [a]
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 LambdaCase where liftEq = genericLiftEq
+instance Ord1 LambdaCase where liftCompare = genericLiftCompare
+instance Show1 LambdaCase where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable LambdaCase
+
+-- For handling guards in function declarations.
+newtype FunctionGuardPattern a = FunctionGuardPattern [a]
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 FunctionGuardPattern where liftEq = genericLiftEq
+instance Ord1 FunctionGuardPattern where liftCompare = genericLiftCompare
+instance Show1 FunctionGuardPattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable FunctionGuardPattern
+
+-- The `y { a = 1, b = 2} in `f y@Example = y { a = 1, b = 2 }`.
+newtype LabeledUpdate a = LabeledUpdate [a]
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 LabeledUpdate where liftEq = genericLiftEq
+instance Ord1 LabeledUpdate where liftCompare = genericLiftCompare
+instance Show1 LabeledUpdate where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable LabeledUpdate
+
+-- The `a = 1` in `f y@Example = y { a = 1, b = 2 }`.
+data FieldBind a = FieldBind { fieldBindLeft :: a, fieldBindRight :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 FieldBind where liftEq = genericLiftEq
+instance Ord1 FieldBind where liftCompare = genericLiftCompare
+instance Show1 FieldBind where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable FieldBind
+
+data ViewPattern a = ViewPattern { viewPatternLeft :: a, viewPatternRight :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 ViewPattern where liftEq = genericLiftEq
+instance Ord1 ViewPattern where liftCompare = genericLiftCompare
+instance Show1 ViewPattern where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable ViewPattern
+
+-- The `a <- b` in `f a | a <- b = c` of a function declaration.
+data PatternGuard a = PatternGuard { patternGuardPattern :: a, patternGuardExpression :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 PatternGuard where liftEq = genericLiftEq
+instance Ord1 PatternGuard where liftCompare = genericLiftCompare
+instance Show1 PatternGuard where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable PatternGuard
+
+data LabeledConstruction a = LabeledConstruction { labeledConstructionConstructor :: a, labeledConstructionFields :: [a] }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 LabeledConstruction where liftEq = genericLiftEq
+instance Ord1 LabeledConstruction where liftCompare = genericLiftCompare
+instance Show1 LabeledConstruction where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable LabeledConstruction
+
+data InfixDataConstructor a = InfixDataConstructor { infixDataConstructorContext :: [a], infixDataConstructorLeft :: a, infixDataConstructorOperator :: a, infixDataConstructorRight :: a }
+  deriving (Declarations1, Diffable, Eq, Foldable, FreeVariables1, Functor, Generic1, Hashable1, Mergeable, Ord, Show, ToJSONFields1, Traversable)
+
+instance Eq1 InfixDataConstructor where liftEq = genericLiftEq
+instance Ord1 InfixDataConstructor where liftCompare = genericLiftCompare
+instance Show1 InfixDataConstructor where liftShowsPrec = genericLiftShowsPrec
+
+instance Evaluatable InfixDataConstructor
--- a/src/Language/Python/Assignment.hs
+++ b/src/Language/Python/Assignment.hs
@ -278,7 +278,7 @@ comparisonOperator = symbol ComparisonOperator *> children (expression `chainl1T
  , (makeTerm1 .) . Expression.Member           <$ symbol AnonIn
  , token AnonIs *> ((makeTerm1 .) . invert Expression.Equal <$ symbol AnonNot <|> pure ((makeTerm1 .) . Expression.Equal))
  ])
-  where invert cons a b = Expression.Not (makeTerm1 (cons a b))
+  where invert cons a b = Expression.Not (makeTerm1 (cons a b))

 notOperator :: Assignment
 notOperator = makeTerm <$> symbol NotOperator <*> children (Expression.Not <$> term expression)
--- a/src/Parsing/Parser.hs
+++ b/src/Parsing/Parser.hs
@ -126,7 +126,7 @@ someParser :: ( ApplyAll typeclasses (Sum Go.Syntax)
              , ApplyAll typeclasses (Sum TypeScript.Syntax)
              , ApplyAll typeclasses (Sum PHP.Syntax)
              )
-           => Language                                        -- ^ The 'Language' to select.
+           => Language                                                -- ^ The 'Language' to select.
           -> Maybe (Parser (SomeTerm typeclasses (Record Location))) -- ^ A 'SomeParser' abstracting the syntax type to be produced.
 someParser Go         = Just (SomeParser goParser)
 someParser Java       = Just (SomeParser javaParser)
--- a/src/Semantic/Parse.hs
+++ b/src/Semantic/Parse.hs
@ -17,7 +17,7 @@ import Semantic.IO (noLanguageForBlob)
 import Semantic.Task
 import Serializing.Format

-runParse :: (Member (Distribute WrappedTask) effs, Member Task effs) => TermRenderer output -> [Blob] -> Eff effs Builder
+runParse :: (Member (Distribute WrappedTask) effs, Member Task effs) => TermRenderer output -> [Blob] -> Eff effs Builder
 runParse JSONTermRenderer             = withParsedBlobs (render . renderJSONTerm) >=> serialize JSON
 runParse SExpressionTermRenderer      = withParsedBlobs (const (serialize (SExpression ByConstructorName)))
 runParse ShowTermRenderer             = withParsedBlobs (const (serialize Show))
--- a/test/fixtures/haskell/corpus/algebraic-datatype-declarations.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/algebraic-datatype-declarations.diffA-B.txt
@ -62,14 +62,6 @@
      ->(TypeConstructorIdentifier) }
        (TypeParameters)
        (Empty))
-      (Constructor
-      { (ConstructorIdentifier)
-      ->(ConstructorIdentifier) }
-        (TypeParameters))
-      (Constructor
-      { (ConstructorIdentifier)
-      ->(ConstructorIdentifier) }
-        (TypeParameters))
    {+(Constructor
      {+(ConstructorIdentifier)+}
      {+(TypeParameters)+})+}
@ -82,6 +74,18 @@
    {+(Constructor
      {+(ConstructorIdentifier)+}
      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(ConstructorIdentifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(ConstructorIdentifier)+}
+      {+(TypeParameters)+})+}
+    {-(Constructor
+      {-(ConstructorIdentifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(ConstructorIdentifier)-}
+      {-(TypeParameters)-})-}
    {-(Constructor
      {-(ConstructorIdentifier)-}
      {-(TypeParameters)-})-}
--- a/test/fixtures/haskell/corpus/algebraic-datatype-declarations.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/algebraic-datatype-declarations.diffB-A.txt
@ -62,14 +62,18 @@
      ->(TypeConstructorIdentifier) }
        (TypeParameters)
        (Empty))
-      (Constructor
-      { (ConstructorIdentifier)
-      ->(ConstructorIdentifier) }
-        (TypeParameters))
-      (Constructor
-      { (ConstructorIdentifier)
-      ->(ConstructorIdentifier) }
-        (TypeParameters))
+    {+(Constructor
+      {+(ConstructorIdentifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(ConstructorIdentifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(ConstructorIdentifier)+}
+      {+(TypeParameters)+})+}
+    {+(Constructor
+      {+(ConstructorIdentifier)+}
+      {+(TypeParameters)+})+}
    {+(Constructor
      {+(ConstructorIdentifier)+}
      {+(TypeParameters)+})+}
@ -77,12 +81,12 @@
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
        (TypeParameters))
-    {+(Constructor
-      {+(ConstructorIdentifier)+}
-      {+(TypeParameters)+})+}
-    {+(Constructor
-      {+(ConstructorIdentifier)+}
-      {+(TypeParameters)+})+}
+    {-(Constructor
+      {-(ConstructorIdentifier)-}
+      {-(TypeParameters)-})-}
+    {-(Constructor
+      {-(ConstructorIdentifier)-}
+      {-(TypeParameters)-})-}
    {-(Constructor
      {-(ConstructorIdentifier)-}
      {-(TypeParameters)-})-}
--- a/test/fixtures/haskell/corpus/expressions.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/expressions.diffA-B.txt
@ -7,6 +7,7 @@
      (Statements
        (App
          (VariableIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -15,7 +16,9 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -25,8 +28,11 @@
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -34,6 +40,7 @@
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -41,6 +48,7 @@
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -50,8 +58,11 @@
          (App
            (App
              (ConstructorIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -61,13 +72,13 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFrom
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) })))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThen
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) }
        { (Integer)
@ -75,7 +86,7 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromTo
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) }
        { (Integer)
@ -83,7 +94,7 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThenTo
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) }
        { (Integer)
@ -167,7 +178,7 @@
            {+(Integer)+}))
          (Generator
            (VariableIdentifier)
-            (EnumFromTo
+            (ArithmeticSequence
              (Integer)
            { (Integer)
            ->(Integer) })))))
@ -188,7 +199,7 @@
              {+(Integer)+})))
          (Generator
            (VariableIdentifier)
-            (EnumFrom
+            (ArithmeticSequence
            { (Integer)
            ->(Integer) })))))
    (Function
@ -198,8 +209,10 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
          { (Integer)
          ->(Integer) })
+          (Empty)
          (ListComprehension
            (ListComprehension
              (Tuple
@ -212,7 +225,7 @@
                  (Integer))))
            (Generator
              (VariableIdentifier)
-              (EnumFrom
+              (ArithmeticSequence
                (Integer)))))))
    (Function
    { (VariableIdentifier)
@ -249,6 +262,7 @@
    {+(Statements
      {+(InfixOperatorApp
        {+(VariableIdentifier)+}
+        {+(Empty)+}
        {+(VariableOperator
          {+(InfixVariableIdentifier)+})+}
        {+(VariableIdentifier)+})+})+})+}
@ -277,6 +291,7 @@
    {-(Statements
      {-(InfixOperatorApp
        {-(VariableIdentifier)-}
+        {-(Empty)-}
        {-(VariableOperator
          {-(InfixVariableIdentifier)-})-}
        {-(VariableIdentifier)-})-})-})-}
@ -298,38 +313,46 @@
      (Statements
        (InfixOperatorApp
          (ConstructorIdentifier)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (InfixOperatorApp
          { (VariableIdentifier)
          ->(VariableIdentifier) }
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (TextElement)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (InfixOperatorApp
              { (VariableIdentifier)
              ->(VariableIdentifier) }
+                (Empty)
                (VariableOperator
                  (VariableSymbol))
                (InfixOperatorApp
                  (TextElement)
+                  (Empty)
                  (VariableOperator
                    (VariableSymbol))
                  (InfixOperatorApp
                  { (VariableIdentifier)
                  ->(VariableIdentifier) }
+                    (Empty)
                    (VariableOperator
                      (VariableSymbol))
                    (InfixOperatorApp
                      (TextElement)
+                      (Empty)
                      (VariableOperator
                        (VariableSymbol))
                      (InfixOperatorApp
                      { (VariableIdentifier)
                      ->(VariableIdentifier) }
+                        (Empty)
                        (VariableOperator
                          (VariableSymbol))
                        (TextElement)))))))))))
@ -344,6 +367,7 @@
            (InfixOperatorApp
            { (VariableIdentifier)
            ->(VariableIdentifier) }
+              (Empty)
              (VariableOperator
                (VariableSymbol))
            { (VariableIdentifier)
@ -354,6 +378,7 @@
            (InfixOperatorApp
            { (VariableIdentifier)
            ->(VariableIdentifier) }
+              (Empty)
              (VariableOperator
                (VariableSymbol))
            { (VariableIdentifier)
@ -383,10 +408,12 @@
          (VariableIdentifier)
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (ConstructorOperator
              (ConstructorSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (ConstructorOperator
                (ConstructorSymbol))
              (VariableIdentifier))))))
@ -401,10 +428,12 @@
            (VariableIdentifier))
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier))))))
@ -420,6 +449,7 @@
      (Statements
        (InfixOperatorApp
          (Integer)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (Integer))))
@ -447,11 +477,13 @@
      (Statements
        (InfixOperatorApp
          (VariableIdentifier)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (Lambda
              { (VariableIdentifier)
              ->(VariableIdentifier) }
@ -459,15 +491,19 @@
                  (Tuple
                  { (VariableIdentifier)
                  ->(VariableIdentifier) })
+                  (Empty)
                  (VariableOperator
                    (VariableSymbol))
                  (InfixOperatorApp
                    (ConstructorIdentifier)
+                    (Empty)
                    (VariableOperator
                      (VariableSymbol))
                    (App
                    { (VariableIdentifier)
                    ->(VariableIdentifier) }
+                      (Empty)
                    { (VariableIdentifier)
                    ->(VariableIdentifier) })))))
+            (Empty)
            (VariableIdentifier)))))))
--- a/test/fixtures/haskell/corpus/expressions.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/expressions.diffB-A.txt
@ -7,6 +7,7 @@
      (Statements
        (App
          (VariableIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -15,7 +16,9 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -25,8 +28,11 @@
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -34,6 +40,7 @@
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -41,6 +48,7 @@
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -50,8 +58,11 @@
          (App
            (App
              (ConstructorIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
    { (VariableIdentifier)
@ -61,13 +72,13 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFrom
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) })))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThen
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) }
        { (Integer)
@ -75,7 +86,7 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromTo
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) }
        { (Integer)
@ -83,7 +94,7 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThenTo
+        (ArithmeticSequence
        { (Integer)
        ->(Integer) }
        { (Integer)
@ -167,7 +178,7 @@
            {-(Integer)-}))
          (Generator
            (VariableIdentifier)
-            (EnumFromTo
+            (ArithmeticSequence
              (Integer)
            { (Integer)
            ->(Integer) })))))
@ -188,7 +199,7 @@
              {-(Integer)-})))
          (Generator
            (VariableIdentifier)
-            (EnumFrom
+            (ArithmeticSequence
            { (Integer)
            ->(Integer) })))))
    (Function
@ -198,8 +209,10 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
          { (Integer)
          ->(Integer) })
+          (Empty)
          (ListComprehension
            (ListComprehension
              (Tuple
@ -212,7 +225,7 @@
                  (Integer))))
            (Generator
              (VariableIdentifier)
-              (EnumFrom
+              (ArithmeticSequence
                (Integer)))))))
    (Function
    { (VariableIdentifier)
@ -263,6 +276,7 @@
    {-(Statements
      {-(InfixOperatorApp
        {-(VariableIdentifier)-}
+        {-(Empty)-}
        {-(VariableOperator
          {-(InfixVariableIdentifier)-})-}
        {-(VariableIdentifier)-})-})-})-}
@ -283,34 +297,42 @@
    {-(Statements
      {-(InfixOperatorApp
        {-(ConstructorIdentifier)-}
+        {-(Empty)-}
        {-(VariableOperator
          {-(VariableSymbol)-})-}
        {-(InfixOperatorApp
          {-(VariableIdentifier)-}
+          {-(Empty)-}
          {-(VariableOperator
            {-(VariableSymbol)-})-}
          {-(InfixOperatorApp
            {-(TextElement)-}
+            {-(Empty)-}
            {-(VariableOperator
              {-(VariableSymbol)-})-}
            {-(InfixOperatorApp
              {-(VariableIdentifier)-}
+              {-(Empty)-}
              {-(VariableOperator
                {-(VariableSymbol)-})-}
              {-(InfixOperatorApp
                {-(TextElement)-}
+                {-(Empty)-}
                {-(VariableOperator
                  {-(VariableSymbol)-})-}
                {-(InfixOperatorApp
                  {-(VariableIdentifier)-}
+                  {-(Empty)-}
                  {-(VariableOperator
                    {-(VariableSymbol)-})-}
                  {-(InfixOperatorApp
                    {-(TextElement)-}
+                    {-(Empty)-}
                    {-(VariableOperator
                      {-(VariableSymbol)-})-}
                    {-(InfixOperatorApp
                      {-(VariableIdentifier)-}
+                      {-(Empty)-}
                      {-(VariableOperator
                        {-(VariableSymbol)-})-}
                      {-(TextElement)-})-})-})-})-})-})-})-})-})-})-}
@ -319,6 +341,7 @@
      (Statements
      {+(InfixOperatorApp
        {+(VariableIdentifier)+}
+        {+(Empty)+}
        {+(VariableOperator
          {+(InfixVariableIdentifier)+})+}
        {+(VariableIdentifier)+})+}
@ -327,6 +350,7 @@
          {-(VariableIdentifier)-}
          {-(InfixOperatorApp
            {-(VariableIdentifier)-}
+            {-(Empty)-}
            {-(VariableOperator
              {-(VariableSymbol)-})-}
            {-(VariableIdentifier)-})-})-}
@ -334,6 +358,7 @@
          {-(VariableIdentifier)-}
          {-(InfixOperatorApp
            {-(VariableIdentifier)-}
+            {-(Empty)-}
            {-(VariableOperator
              {-(VariableSymbol)-})-}
            {-(VariableIdentifier)-})-})-})-}))
@ -354,34 +379,42 @@
    {+(Statements
      {+(InfixOperatorApp
        {+(ConstructorIdentifier)+}
+        {+(Empty)+}
        {+(VariableOperator
          {+(VariableSymbol)+})+}
        {+(InfixOperatorApp
          {+(VariableIdentifier)+}
+          {+(Empty)+}
          {+(VariableOperator
            {+(VariableSymbol)+})+}
          {+(InfixOperatorApp
            {+(TextElement)+}
+            {+(Empty)+}
            {+(VariableOperator
              {+(VariableSymbol)+})+}
            {+(InfixOperatorApp
              {+(VariableIdentifier)+}
+              {+(Empty)+}
              {+(VariableOperator
                {+(VariableSymbol)+})+}
              {+(InfixOperatorApp
                {+(TextElement)+}
+                {+(Empty)+}
                {+(VariableOperator
                  {+(VariableSymbol)+})+}
                {+(InfixOperatorApp
                  {+(VariableIdentifier)+}
+                  {+(Empty)+}
                  {+(VariableOperator
                    {+(VariableSymbol)+})+}
                  {+(InfixOperatorApp
                    {+(TextElement)+}
+                    {+(Empty)+}
                    {+(VariableOperator
                      {+(VariableSymbol)+})+}
                    {+(InfixOperatorApp
                      {+(VariableIdentifier)+}
+                      {+(Empty)+}
                      {+(VariableOperator
                        {+(VariableSymbol)+})+}
                      {+(TextElement)+})+})+})+})+})+})+})+})+})+})+}
@ -393,6 +426,7 @@
          {+(VariableIdentifier)+}
          {+(InfixOperatorApp
            {+(VariableIdentifier)+}
+            {+(Empty)+}
            {+(VariableOperator
              {+(VariableSymbol)+})+}
            {+(VariableIdentifier)+})+})+}
@ -400,6 +434,7 @@
          {+(VariableIdentifier)+}
          {+(InfixOperatorApp
            {+(VariableIdentifier)+}
+            {+(Empty)+}
            {+(VariableOperator
              {+(VariableSymbol)+})+}
            {+(VariableIdentifier)+})+})+})+})+})+}
@ -428,10 +463,12 @@
          (VariableIdentifier)
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (ConstructorOperator
              (ConstructorSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (ConstructorOperator
                (ConstructorSymbol))
              (VariableIdentifier))))))
@ -446,10 +483,12 @@
            (VariableIdentifier))
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier))))))
@ -465,6 +504,7 @@
      (Statements
        (InfixOperatorApp
          (Integer)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (Integer))))
@ -492,11 +532,13 @@
      (Statements
        (InfixOperatorApp
          (VariableIdentifier)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (Lambda
              { (VariableIdentifier)
              ->(VariableIdentifier) }
@ -504,15 +546,19 @@
                  (Tuple
                  { (VariableIdentifier)
                  ->(VariableIdentifier) })
+                  (Empty)
                  (VariableOperator
                    (VariableSymbol))
                  (InfixOperatorApp
                    (ConstructorIdentifier)
+                    (Empty)
                    (VariableOperator
                      (VariableSymbol))
                    (App
                    { (VariableIdentifier)
                    ->(VariableIdentifier) }
+                      (Empty)
                    { (VariableIdentifier)
                    ->(VariableIdentifier) })))))
+            (Empty)
            (VariableIdentifier)))))))
--- a/test/fixtures/haskell/corpus/expressions.parseA.txt
+++ b/test/fixtures/haskell/corpus/expressions.parseA.txt
@ -6,6 +6,7 @@
      (Statements
        (App
          (VariableIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -13,7 +14,9 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -22,20 +25,25 @@
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -44,8 +52,11 @@
          (App
            (App
              (ConstructorIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -54,24 +65,24 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFrom
+        (ArithmeticSequence
          (Integer))))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThen
+        (ArithmeticSequence
          (Integer)
          (Integer))))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromTo
+        (ArithmeticSequence
          (Integer)
          (Integer))))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThenTo
+        (ArithmeticSequence
          (Integer)
          (Integer)
          (Integer))))
@ -137,7 +148,7 @@
              (Integer)))
          (Generator
            (VariableIdentifier)
-            (EnumFromTo
+            (ArithmeticSequence
              (Integer)
              (Integer))))))
    (Function
@ -155,7 +166,7 @@
                (Integer))))
          (Generator
            (VariableIdentifier)
-            (EnumFrom
+            (ArithmeticSequence
              (Integer))))))
    (Function
      (VariableIdentifier)
@ -163,7 +174,9 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
            (Integer))
+          (Empty)
          (ListComprehension
            (ListComprehension
              (Tuple
@ -176,7 +189,7 @@
                  (Integer))))
            (Generator
              (VariableIdentifier)
-              (EnumFrom
+              (ArithmeticSequence
                (Integer)))))))
    (Function
      (VariableIdentifier)
@ -211,6 +224,7 @@
      (Statements
        (InfixOperatorApp
          (VariableIdentifier)
+          (Empty)
          (VariableOperator
            (InfixVariableIdentifier))
          (VariableIdentifier))))
@ -231,34 +245,42 @@
      (Statements
        (InfixOperatorApp
          (ConstructorIdentifier)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (TextElement)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (InfixOperatorApp
                (VariableIdentifier)
+                (Empty)
                (VariableOperator
                  (VariableSymbol))
                (InfixOperatorApp
                  (TextElement)
+                  (Empty)
                  (VariableOperator
                    (VariableSymbol))
                  (InfixOperatorApp
                    (VariableIdentifier)
+                    (Empty)
                    (VariableOperator
                      (VariableSymbol))
                    (InfixOperatorApp
                      (TextElement)
+                      (Empty)
                      (VariableOperator
                        (VariableSymbol))
                      (InfixOperatorApp
                        (VariableIdentifier)
+                        (Empty)
                        (VariableOperator
                          (VariableSymbol))
                        (TextElement)))))))))))
@ -270,6 +292,7 @@
            (VariableIdentifier)
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier)))
@ -277,6 +300,7 @@
            (VariableIdentifier)
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier))))))
@ -302,10 +326,12 @@
          (VariableIdentifier)
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (ConstructorOperator
              (ConstructorSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (ConstructorOperator
                (ConstructorSymbol))
              (VariableIdentifier))))))
@ -319,10 +345,12 @@
            (VariableIdentifier))
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier))))))
@ -336,6 +364,7 @@
      (Statements
        (InfixOperatorApp
          (Integer)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (Integer))))
@ -359,23 +388,29 @@
      (Statements
        (InfixOperatorApp
          (VariableIdentifier)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (Lambda
                (VariableIdentifier)
                (InfixOperatorApp
                  (Tuple
                    (VariableIdentifier))
+                  (Empty)
                  (VariableOperator
                    (VariableSymbol))
                  (InfixOperatorApp
                    (ConstructorIdentifier)
+                    (Empty)
                    (VariableOperator
                      (VariableSymbol))
                    (App
                      (VariableIdentifier)
+                      (Empty)
                      (VariableIdentifier))))))
+            (Empty)
            (VariableIdentifier)))))))
--- a/test/fixtures/haskell/corpus/expressions.parseB.txt
+++ b/test/fixtures/haskell/corpus/expressions.parseB.txt
@ -6,6 +6,7 @@
      (Statements
        (App
          (VariableIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -13,7 +14,9 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -22,20 +25,25 @@
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
      (Statements
        (App
          (ConstructorIdentifier)
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -44,8 +52,11 @@
          (App
            (App
              (ConstructorIdentifier)
+              (Empty)
              (VariableIdentifier))
+            (Empty)
            (VariableIdentifier))
+          (Empty)
          (VariableIdentifier))))
    (Function
      (VariableIdentifier)
@ -54,24 +65,24 @@
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFrom
+        (ArithmeticSequence
          (Integer))))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThen
+        (ArithmeticSequence
          (Integer)
          (Integer))))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromTo
+        (ArithmeticSequence
          (Integer)
          (Integer))))
    (Function
      (VariableIdentifier)
      (Statements
-        (EnumFromThenTo
+        (ArithmeticSequence
          (Integer)
          (Integer)
          (Integer))))
@ -139,7 +150,7 @@
              (Integer)))
          (Generator
            (VariableIdentifier)
-            (EnumFromTo
+            (ArithmeticSequence
              (Integer)
              (Integer))))))
    (Function
@ -157,7 +168,7 @@
                (Integer))))
          (Generator
            (VariableIdentifier)
-            (EnumFrom
+            (ArithmeticSequence
              (Integer))))))
    (Function
      (VariableIdentifier)
@ -165,7 +176,9 @@
        (App
          (App
            (VariableIdentifier)
+            (Empty)
            (Integer))
+          (Empty)
          (ListComprehension
            (ListComprehension
              (Tuple
@ -178,7 +191,7 @@
                  (Integer))))
            (Generator
              (VariableIdentifier)
-              (EnumFrom
+              (ArithmeticSequence
                (Integer)))))))
    (Function
      (VariableIdentifier)
@ -213,6 +226,7 @@
      (Statements
        (InfixOperatorApp
          (VariableIdentifier)
+          (Empty)
          (VariableOperator
            (InfixVariableIdentifier))
          (VariableIdentifier))))
@ -233,34 +247,42 @@
      (Statements
        (InfixOperatorApp
          (ConstructorIdentifier)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (TextElement)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (InfixOperatorApp
                (VariableIdentifier)
+                (Empty)
                (VariableOperator
                  (VariableSymbol))
                (InfixOperatorApp
                  (TextElement)
+                  (Empty)
                  (VariableOperator
                    (VariableSymbol))
                  (InfixOperatorApp
                    (VariableIdentifier)
+                    (Empty)
                    (VariableOperator
                      (VariableSymbol))
                    (InfixOperatorApp
                      (TextElement)
+                      (Empty)
                      (VariableOperator
                        (VariableSymbol))
                      (InfixOperatorApp
                        (VariableIdentifier)
+                        (Empty)
                        (VariableOperator
                          (VariableSymbol))
                        (TextElement)))))))))))
@ -272,6 +294,7 @@
            (VariableIdentifier)
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier)))
@ -279,6 +302,7 @@
            (VariableIdentifier)
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier))))))
@ -304,10 +328,12 @@
          (VariableIdentifier)
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (ConstructorOperator
              (ConstructorSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (ConstructorOperator
                (ConstructorSymbol))
              (VariableIdentifier))))))
@ -321,10 +347,12 @@
            (VariableIdentifier))
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier))))))
@ -338,6 +366,7 @@
      (Statements
        (InfixOperatorApp
          (Integer)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (Integer))))
@ -361,23 +390,29 @@
      (Statements
        (InfixOperatorApp
          (VariableIdentifier)
+          (Empty)
          (VariableOperator
            (VariableSymbol))
          (App
            (App
              (VariableIdentifier)
+              (Empty)
              (Lambda
                (VariableIdentifier)
                (InfixOperatorApp
                  (Tuple
                    (VariableIdentifier))
+                  (Empty)
                  (VariableOperator
                    (VariableSymbol))
                  (InfixOperatorApp
                    (ConstructorIdentifier)
+                    (Empty)
                    (VariableOperator
                      (VariableSymbol))
                    (App
                      (VariableIdentifier)
+                      (Empty)
                      (VariableIdentifier))))))
+            (Empty)
            (VariableIdentifier)))))))
--- a/test/fixtures/haskell/corpus/function-declarations.A.hs
+++ b/test/fixtures/haskell/corpus/function-declarations.A.hs
@ -0,0 +1,159 @@
+f num1 num2 = num2
+f (Ex 1) = Ex 1
+f n@num1 x@num2 = x
+f _ num2 = num2
+f 1 2 = 3
+f "hello" "world" = "goodbye"
+f 'a' 'b' = 'c'
+f 1.0 2.0 = 3.0
+f Ex { a = 1 } = 1
+f Ex { a = 1, b = 2 } = 2
+f Ex {} = 2
+f Blob{start, end} = [start, end]
+f Blob{..} = [start, end]
+f Blob{start, end = end', ..} = [start, end', name, path]
+f (1) = 1
+f (-(1)) = 1
+f (Example a b c) = a
+f (a :<: f) = 2
+f ([]) = 1
+f (1, 2) = 1
+f ((Just 1), Just 2) = Just 1
+f (Just a, Nothing) = Nothing
+f (Left a, Right b, -(1)) = b
+f [] = 0
+f [a] = a
+f (a:bs) = a
+f (a:b:cs) = a
+f (a:b:c:ds) = a
+f ~a = 1
+f ~(-(1)) = 1
+f ~(~(a, b), c) = c
+f x = case x of
+  Just a | a < 10 -> True
+         | a < 20 -> False
+         | a > 19 -> True
+
+g x = case x of
+  Just a | a < 10, True, let b :: Int -> Int
+                             b x = x -> True
+  Nothing -> False
+
+f x = case x of
+  Just _ -> x where x = True
+  Nothing -> False
+
+f a = case a of
+  Just a -> g
+    where g = h
+          h = 1
+  Nothing -> i
+    where i = j
+          j = 2
+
+f a = case a of
+  Just a -> g
+  Nothing -> i
+  where g = 1
+        i = 2
+
+f = (
+    \ a ->
+      case a of
+        A -> b
+        )
+a = reify tcName >>= \case
+      TyConI (DataD _ _ _ _ cons _) -> do
+        sigs <- filter (const makeSigs) <$> traverse genSig cons
+        decs <- traverse genDecl cons
+        pure $ sigs ++ decs
+
+      _ ->
+        fail "makeEff expects a type constructor"
+
+f x | x < 10, x > 2 = True
+    | otherwise = False
+
+f x = do
+  let z = x
+  y <- a
+  pure y
+
+f x = do
+  let z = x
+  a
+  y
+  where y = pure a
+        a = 1
+
+f y@Example = y { a = 1, b = 2 }
+f y@(Example { a = a', b = b' }) = y { a = a' + 1, b = b' ++ " !" }
+
+f = read @Int
+f = read @Int "5"
+f = read @Prelude.Int "5"
+f = read @Int . Prelude.id
+f = read @Prelude.Int . Prelude.id
+f = read @Int . id
+f = read @Prelude.Int . Prelude.id
+f = read @Int .id
+f = read @Prelude.Int .Prelude.id
+f = read @Int. id
+f = read @Prelude.Int. Prelude.id
+f = read @(x (Bar a))
+
+f = Data.List.uncons . id
+f = Data.List.uncons . Prelude.id
+f = Data.List.uncons. id
+f = Data.List.uncons. Prelude.id
+f = Data.List.uncons .id
+f = Data.List.uncons .Prelude.id
+f = Data.List.uncons.id
+f = Data.List.uncons.Prelude.id
+
+f = Bar ': Baz
+f = Bar ':<: Baz
+
+f = (<>)
+f = a <>
+
+f = 1 where
+g = 2 where
+
+f = a where
+  {- comment -}
+f = a where
+  {-
+-}
+f = a where
+  --
+f = a where
+  {-# COLUMN 42 #-}
+
+b = 2
+
+eval (a :< b) (fmap subtermValue -> QualifiedName name iden) = bar
+
+sort :: (?cmp :: a -> a -> Bool) => [a] -> [a]
+sort = sortBy ?cmp
+
+b (E (u :: Union e b) q) = a
+
+ifte :: ( IvoryStore a
+        , IvoryZero ('Stored a)
+        , GetAlloc eff ~ 'Scope s
+        ) => IBool
+          -> Ivory eff a
+          -> Ivory eff a
+          -> Ivory eff a
+
+haystackClient maybeURL managerSettings appName
+  | Just url <- maybeURL = do
+      manager  <- newManager managerSettings
+      request' <- parseRequest url
+      let request = request'
+            { method = "POST"
+            , requestHeaders = ("Content-Type", "application/json; charset=utf-8") : requestHeaders request'
+            }
+      pure $ HaystackClient request manager appName
+  | otherwise = pure NullHaystackClient
--- a/test/fixtures/haskell/corpus/function-declarations.B.hs
+++ b/test/fixtures/haskell/corpus/function-declarations.B.hs
@ -0,0 +1,160 @@
+g num1 num2 = num2
+g (Ex 1) = Ex 1
+g n@num1 x@num2 = x
+g _ num2 = num2
+g 1 2 = 3
+g "hello" "world" = "goodbye"
+g 'a' 'b' = 'c'
+g 1.0 2.0 = 3.0
+g Ex { a = 1 } = 1
+g Ex { a = 1, b = 2 } = 2
+g Ex {} = 2
+g Blob{start, end} = [start, end]
+g Blob{..} = [start, end]
+g Blob{start, end = end', ..} = [start, end', name, path]
+g c@Ex { a = 1 } = c
+g (1) = 1
+g (-(1)) = 1
+g (Example a b c) = a
+g (a :<: f) = 2
+g ([]) = 1
+g (1, 2) = 1
+g ((Just 1), Just 2) = Just 1
+g (Just a, Nothing) = Nothing
+g (Left a, Right b, -(1)) = b
+g [] = 0
+g [a] = a
+g (a:bs) = a
+g (a:b:cs) = a
+g (a:b:c:ds) = a
+g ~a = 1
+g ~(-(1)) = 1
+g ~(~(a, b), c) = c
+g x = case x of
+  Just a | a < 10 -> True
+         | a < 20 -> False
+         | a > 19 -> True
+
+f x = case x of
+  Just a | a < 10, True, let b :: Int -> Int
+                             b x = x -> True
+  Nothing -> False
+
+g x = case x of
+  Just _ -> x where x = True
+  Nothing -> False
+
+g a = case a of
+  Just a -> g
+    where g = h
+          h = 1
+  Nothing -> i
+    where i = j
+          j = 2
+
+g a = case a of
+  Just a -> g
+  Nothing -> i
+  where g = 1
+        i = 2
+
+g = (
+    \ a ->
+      case a of
+        A -> b
+        )
+b = reify tcName >>= \case
+      TyConI (DataD _ _ _ _ cons _) -> do
+        sigs <- filter (const makeSigs) <$> traverse genSig cons
+        decs <- traverse genDecl cons
+        pure $ sigs ++ decs
+
+      _ ->
+        fail "makeEff expects a type constructor"
+
+g y | y < 10, y > 2 = True
+    | otherwise = False
+
+g x = do
+  let z = x
+  y <- a
+  pure y
+
+g x = do
+  let z = x
+  a
+  y
+  where y = pure a
+        a = 1
+
+g y@Example = y { a = 1, b = 2 }
+g y@(Example { a = a', b = b' }) = y { a = a' + 1, b = b' ++ " !" }
+
+g = read @Int
+g = read @Int "5"
+g = read @Prelude.Int "5"
+g = read @Int . Prelude.id
+g = read @Prelude.Int . Prelude.id
+g = read @Int . id
+g = read @Prelude.Int . Prelude.id
+g = read @Int .id
+g = read @Prelude.Int .Prelude.id
+g = read @Int. id
+g = read @Prelude.Int. Prelude.id
+g = read @(x (Bar a))
+
+g = Data.List.uncons . id
+g = Data.List.uncons . Prelude.id
+g = Data.List.uncons. id
+g = Data.List.uncons. Prelude.id
+g = Data.List.uncons .id
+g = Data.List.uncons .Prelude.id
+g = Data.List.uncons.id
+g = Data.List.uncons.Prelude.id
+
+g = Bar ': Baz
+g = Bar ':<: Baz
+
+g = (<>)
+g = a <>
+
+g = 1 where
+h = 2 where
+
+g = a where
+  {- comment -}
+g = a where
+  {-
+-}
+g = a where
+  --
+g = a where
+  {-# COLUMN 42 #-}
+
+c = 2
+
+eval' (a :< b) (fmap subtermValue -> QualifiedName name' iden) = foo
+
+sort' :: (?cmp :: a -> a -> Bool) => [a] -> [a]
+sort' = sortBy ?cmp
+
+c (F (u :: Union e b) q) = b
+
+g :: ( IvoryStore a
+     , IvoryZero ('Stored a)
+     , GetAlloc eff ~ 'Scope s
+     ) => IBool
+       -> Ivory eff a
+       -> Ivory eff a
+       -> Ivory eff a
+
+needlestackClient maybeURL directorSettings appName
+  | Just url <- maybeURL = do
+      director  <- newDirector directorSettings
+      request' <- parseRequest url
+      let request = request'
+            { method = "POST"
+            , requestHeaders = ("Content-Type", "application/json; charset=utf-8") : requestHeaders request'
+            }
+      pure $ NeedlestackClient request director appName
+  | otherwise = pure NullNeedlestackClient
--- a/test/fixtures/haskell/corpus/function-declarations.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/function-declarations.diffA-B.txt
--- a/test/fixtures/haskell/corpus/function-declarations.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/function-declarations.diffB-A.txt
--- a/test/fixtures/haskell/corpus/function-declarations.parseA.txt
+++ b/test/fixtures/haskell/corpus/function-declarations.parseA.txt
--- a/test/fixtures/haskell/corpus/function-declarations.parseB.txt
+++ b/test/fixtures/haskell/corpus/function-declarations.parseB.txt
--- a/test/fixtures/haskell/corpus/gadt-declarations.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/gadt-declarations.diffA-B.txt
@ -183,7 +183,7 @@
        (GADTConstructor
          (Empty)
          (TypeConstructorIdentifier)
-          (Context
+          (Statements
            (Pragma)
            (FunctionType
              (Type
--- a/test/fixtures/haskell/corpus/gadt-declarations.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/gadt-declarations.diffB-A.txt
@ -183,7 +183,7 @@
        (GADTConstructor
          (Empty)
          (TypeConstructorIdentifier)
-          (Context
+          (Statements
            (Pragma)
            (FunctionType
              (Type
--- a/test/fixtures/haskell/corpus/gadt-declarations.parseA.txt
+++ b/test/fixtures/haskell/corpus/gadt-declarations.parseA.txt
@ -171,7 +171,7 @@
        (GADTConstructor
          (Empty)
          (TypeConstructorIdentifier)
-          (Context
+          (Statements
            (Pragma)
            (FunctionType
              (Type
--- a/test/fixtures/haskell/corpus/gadt-declarations.parseB.txt
+++ b/test/fixtures/haskell/corpus/gadt-declarations.parseB.txt
@ -172,7 +172,7 @@
        (GADTConstructor
          (Empty)
          (TypeConstructorIdentifier)
-          (Context
+          (Statements
            (Pragma)
            (FunctionType
              (Type
--- a/test/fixtures/haskell/corpus/layout.A.hs
+++ b/test/fixtures/haskell/corpus/layout.A.hs
@ -0,0 +1,52 @@
+f = let y = x
+        x = let g = 1
+                in g
+        in y
+
+f = a
+  where a = b
+        b = 1
+
+f = a
+  where a = b
+        b = 1
+
+f = foo
+  where a = b
+          where c = d
+                e = f
+        x = w
+
+g = do c
+       a
+       do b
+          e
+          do g
+             g
+          h
+       i
+
+a = do
+  b
+    where
+    c = d
+
+a = do
+  b
+  where
+    c = d
+
+a = do
+  b
+  where
+  c = d
+  
+class Foo bar where
+  fooVariables :: bar -> [Baz]
+{-
+-}
+class Foo1 bar where
+  liftFoo = foldMap
+
+freeFoo bar = case freeFoo bar of
+  [n] -> Right n
--- a/test/fixtures/haskell/corpus/layout.B.hs
+++ b/test/fixtures/haskell/corpus/layout.B.hs
@ -0,0 +1,42 @@
+f = let x = y
+        y = let h = 1
+                in h
+        in x
+
+f = b
+  where b = a
+        a = 1
+
+f = c
+  where c = b
+        b = 1
+
+f = bar
+  where c = a
+          where a = e
+                e = f
+        w = x
+
+g = do a
+       b
+       do c
+          d
+          do e
+             f
+          g
+       h
+
+b = do
+  a
+    where
+    d = c
+
+b = do
+  c
+  where
+    c = e
+
+b = do
+  a
+  where
+  a = f
--- a/test/fixtures/haskell/corpus/layout.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/layout.diffA-B.txt
@ -0,0 +1,212 @@
+(Module
+  (Empty)
+  (Statements
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Let
+        {-(Function
+          {-(VariableIdentifier)-}
+          {-(Statements
+            {-(VariableIdentifier)-})-})-}
+          (Function
+            (VariableIdentifier)
+            (Statements
+            {+(VariableIdentifier)+}
+            {-(Let
+              {-(Function
+                {-(VariableIdentifier)-}
+                {-(Statements
+                  {-(Integer)-})-})-}
+              {-(VariableIdentifier)-})-}))
+        {+(Function
+          {+(VariableIdentifier)+}
+          {+(Statements
+            {+(Let
+              {+(Function
+                {+(VariableIdentifier)+}
+                {+(Statements
+                  {+(Integer)+})+})+}
+              {+(VariableIdentifier)+})+})+})+}
+        { (VariableIdentifier)
+        ->(VariableIdentifier) })))
+    (Function
+      (VariableIdentifier)
+      (Statements
+      { (VariableIdentifier)
+      ->(VariableIdentifier) }
+        (Statements
+        {-(Function
+          {-(VariableIdentifier)-}
+          {-(Statements
+            {-(VariableIdentifier)-})-})-}
+          (Function
+            (VariableIdentifier)
+            (Statements
+            {+(VariableIdentifier)+}
+            {-(Integer)-}))
+        {+(Function
+          {+(VariableIdentifier)+}
+          {+(Statements
+            {+(Integer)+})+})+})))
+    (Function
+      (VariableIdentifier)
+      (Statements
+      { (VariableIdentifier)
+      ->(VariableIdentifier) }
+        (Statements
+          (Function
+          { (VariableIdentifier)
+          ->(VariableIdentifier) }
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Integer))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+      { (VariableIdentifier)
+      ->(VariableIdentifier) }
+        (Statements
+          (Function
+          { (VariableIdentifier)
+          ->(VariableIdentifier) }
+            (Statements
+            { (VariableIdentifier)
+            ->(VariableIdentifier) }
+              (Statements
+                (Function
+                { (VariableIdentifier)
+                ->(VariableIdentifier) }
+                  (Statements
+                  { (VariableIdentifier)
+                  ->(VariableIdentifier) }))
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (VariableIdentifier))))))
+          (Function
+          { (VariableIdentifier)
+          ->(VariableIdentifier) }
+            (Statements
+            { (VariableIdentifier)
+            ->(VariableIdentifier) })))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+        {-(VariableIdentifier)-}
+          (VariableIdentifier)
+        {+(VariableIdentifier)+}
+          (Do
+          {+(VariableIdentifier)+}
+          {+(VariableIdentifier)+}
+          {+(Do
+            {+(VariableIdentifier)+}
+            {+(VariableIdentifier)+})+}
+          { (VariableIdentifier)
+          ->(VariableIdentifier) }
+          {-(VariableIdentifier)-}
+          {-(Do
+            {-(VariableIdentifier)-}
+            {-(VariableIdentifier)-})-}
+          {-(VariableIdentifier)-})
+        { (VariableIdentifier)
+        ->(VariableIdentifier) })))
+    (Function
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (Statements
+        (Do
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (Statements
+            (Function
+            { (VariableIdentifier)
+            ->(VariableIdentifier) }
+              (Statements
+              { (VariableIdentifier)
+              ->(VariableIdentifier) }))))))
+  {+(Function
+    {+(VariableIdentifier)+}
+    {+(Statements
+      {+(Do
+        {+(VariableIdentifier)+}
+        {+(Statements
+          {+(Function
+            {+(VariableIdentifier)+}
+            {+(Statements
+              {+(VariableIdentifier)+})+})+})+})+})+})+}
+    (Function
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (Statements
+        (Do
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (Statements
+            (Function
+            { (VariableIdentifier)
+            ->(VariableIdentifier) }
+              (Statements
+              { (VariableIdentifier)
+              ->(VariableIdentifier) }))))))
+  {-(Function
+    {-(VariableIdentifier)-}
+    {-(Statements
+      {-(Do
+        {-(VariableIdentifier)-}
+        {-(Statements
+          {-(Function
+            {-(VariableIdentifier)-}
+            {-(Statements
+              {-(VariableIdentifier)-})-})-})-})-})-})-}
+  {-(TypeClass
+    {-(Empty)-}
+    {-(TypeClassIdentifier)-}
+    {-(TypeVariableIdentifier)-}
+    {-(Statements
+      {-(Context
+        {-(Comment)-}
+        {-(TypeSignature
+          {-(VariableIdentifier)-}
+          {-(FunctionType
+            {-(Type
+              {-(TypeVariableIdentifier)-}
+              {-(TypeParameters)-}
+              {-(Empty)-})-}
+            {-(Type
+              {-(Array
+                {-(Type
+                  {-(TypeConstructorIdentifier)-}
+                  {-(TypeParameters)-}
+                  {-(Empty)-})-})-}
+              {-(TypeParameters)-}
+              {-(Empty)-})-})-})-})-})-})-}
+  {-(TypeClass
+    {-(Empty)-}
+    {-(TypeClassIdentifier)-}
+    {-(TypeVariableIdentifier)-}
+    {-(Statements
+      {-(Function
+        {-(VariableIdentifier)-}
+        {-(Statements
+          {-(VariableIdentifier)-})-})-})-})-}
+  {-(Function
+    {-(VariableIdentifier)-}
+    {-(VariableIdentifier)-}
+    {-(Statements
+      {-(Match
+        {-(App
+          {-(VariableIdentifier)-}
+          {-(Empty)-}
+          {-(VariableIdentifier)-})-}
+        {-(Pattern
+          {-(ListPattern
+            {-(VariableIdentifier)-})-}
+          {-(App
+            {-(ConstructorIdentifier)-}
+            {-(Empty)-}
+            {-(VariableIdentifier)-})-})-})-})-})-}))
--- a/test/fixtures/haskell/corpus/layout.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/layout.diffB-A.txt
@ -0,0 +1,219 @@
+(Module
+  (Empty)
+  (Statements
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Let
+        {-(Function
+          {-(VariableIdentifier)-}
+          {-(Statements
+            {-(VariableIdentifier)-})-})-}
+          (Function
+            (VariableIdentifier)
+            (Statements
+            {+(VariableIdentifier)+}
+            {-(Let
+              {-(Function
+                {-(VariableIdentifier)-}
+                {-(Statements
+                  {-(Integer)-})-})-}
+              {-(VariableIdentifier)-})-}))
+        {+(Function
+          {+(VariableIdentifier)+}
+          {+(Statements
+            {+(Let
+              {+(Function
+                {+(VariableIdentifier)+}
+                {+(Statements
+                  {+(Integer)+})+})+}
+              {+(VariableIdentifier)+})+})+})+}
+        { (VariableIdentifier)
+        ->(VariableIdentifier) })))
+    (Function
+      (VariableIdentifier)
+      (Statements
+      { (VariableIdentifier)
+      ->(VariableIdentifier) }
+        (Statements
+        {-(Function
+          {-(VariableIdentifier)-}
+          {-(Statements
+            {-(VariableIdentifier)-})-})-}
+          (Function
+            (VariableIdentifier)
+            (Statements
+            {+(VariableIdentifier)+}
+            {-(Integer)-}))
+        {+(Function
+          {+(VariableIdentifier)+}
+          {+(Statements
+            {+(Integer)+})+})+})))
+    (Function
+      (VariableIdentifier)
+      (Statements
+      { (VariableIdentifier)
+      ->(VariableIdentifier) }
+        (Statements
+          (Function
+          { (VariableIdentifier)
+          ->(VariableIdentifier) }
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Integer))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+      { (VariableIdentifier)
+      ->(VariableIdentifier) }
+        (Statements
+          (Function
+          { (VariableIdentifier)
+          ->(VariableIdentifier) }
+            (Statements
+            { (VariableIdentifier)
+            ->(VariableIdentifier) }
+              (Statements
+                (Function
+                { (VariableIdentifier)
+                ->(VariableIdentifier) }
+                  (Statements
+                  { (VariableIdentifier)
+                  ->(VariableIdentifier) }))
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (VariableIdentifier))))))
+          (Function
+          { (VariableIdentifier)
+          ->(VariableIdentifier) }
+            (Statements
+            { (VariableIdentifier)
+            ->(VariableIdentifier) })))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+        {+(VariableIdentifier)+}
+          (VariableIdentifier)
+        {+(Do
+          {+(VariableIdentifier)+}
+          {+(VariableIdentifier)+}
+          {+(Do
+            {+(VariableIdentifier)+}
+            {+(VariableIdentifier)+})+}
+          {+(VariableIdentifier)+})+}
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+        {-(Do
+          {-(VariableIdentifier)-}
+          {-(VariableIdentifier)-}
+          {-(Do
+            {-(VariableIdentifier)-}
+            {-(VariableIdentifier)-})-}
+          {-(VariableIdentifier)-})-}
+        {-(VariableIdentifier)-})))
+    (Function
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (Statements
+        (Do
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (Statements
+            (Function
+            { (VariableIdentifier)
+            ->(VariableIdentifier) }
+              (Statements
+              { (VariableIdentifier)
+              ->(VariableIdentifier) }))))))
+  {+(Function
+    {+(VariableIdentifier)+}
+    {+(Statements
+      {+(Do
+        {+(VariableIdentifier)+}
+        {+(Statements
+          {+(Function
+            {+(VariableIdentifier)+}
+            {+(Statements
+              {+(VariableIdentifier)+})+})+})+})+})+})+}
+  {+(Function
+    {+(VariableIdentifier)+}
+    {+(Statements
+      {+(Do
+        {+(VariableIdentifier)+}
+        {+(Statements
+          {+(Function
+            {+(VariableIdentifier)+}
+            {+(Statements
+              {+(VariableIdentifier)+})+})+})+})+})+})+}
+  {+(TypeClass
+    {+(Empty)+}
+    {+(TypeClassIdentifier)+}
+    {+(TypeVariableIdentifier)+}
+    {+(Statements
+      {+(Context
+        {+(Comment)+}
+        {+(TypeSignature
+          {+(VariableIdentifier)+}
+          {+(FunctionType
+            {+(Type
+              {+(TypeVariableIdentifier)+}
+              {+(TypeParameters)+}
+              {+(Empty)+})+}
+            {+(Type
+              {+(Array
+                {+(Type
+                  {+(TypeConstructorIdentifier)+}
+                  {+(TypeParameters)+}
+                  {+(Empty)+})+})+}
+              {+(TypeParameters)+}
+              {+(Empty)+})+})+})+})+})+})+}
+  {+(TypeClass
+    {+(Empty)+}
+    {+(TypeClassIdentifier)+}
+    {+(TypeVariableIdentifier)+}
+    {+(Statements
+      {+(Function
+        {+(VariableIdentifier)+}
+        {+(Statements
+          {+(VariableIdentifier)+})+})+})+})+}
+  {+(Function
+    {+(VariableIdentifier)+}
+    {+(VariableIdentifier)+}
+    {+(Statements
+      {+(Match
+        {+(App
+          {+(VariableIdentifier)+}
+          {+(Empty)+}
+          {+(VariableIdentifier)+})+}
+        {+(Pattern
+          {+(ListPattern
+            {+(VariableIdentifier)+})+}
+          {+(App
+            {+(ConstructorIdentifier)+}
+            {+(Empty)+}
+            {+(VariableIdentifier)+})+})+})+})+})+}
+  {-(Function
+    {-(VariableIdentifier)-}
+    {-(Statements
+      {-(Do
+        {-(VariableIdentifier)-}
+        {-(Statements
+          {-(Function
+            {-(VariableIdentifier)-}
+            {-(Statements
+              {-(VariableIdentifier)-})-})-})-})-})-})-}
+  {-(Function
+    {-(VariableIdentifier)-}
+    {-(Statements
+      {-(Do
+        {-(VariableIdentifier)-}
+        {-(Statements
+          {-(Function
+            {-(VariableIdentifier)-}
+            {-(Statements
+              {-(VariableIdentifier)-})-})-})-})-})-})-}))
--- a/test/fixtures/haskell/corpus/layout.parseA.txt
+++ b/test/fixtures/haskell/corpus/layout.parseA.txt
@ -0,0 +1,160 @@
+(Module
+  (Empty)
+  (Statements
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Let
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Let
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (Integer)))
+                (VariableIdentifier))))
+          (VariableIdentifier))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (Statements
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Integer))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (Statements
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Integer))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (Statements
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)
+              (Statements
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (VariableIdentifier)))
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (VariableIdentifier))))))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (VariableIdentifier)
+          (Do
+            (VariableIdentifier)
+            (VariableIdentifier)
+            (Do
+              (VariableIdentifier)
+              (VariableIdentifier))
+            (VariableIdentifier))
+          (VariableIdentifier))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (Statements
+            (Function
+              (VariableIdentifier)
+              (Statements
+                (VariableIdentifier)))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (Statements
+            (Function
+              (VariableIdentifier)
+              (Statements
+                (VariableIdentifier)))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (Statements
+            (Function
+              (VariableIdentifier)
+              (Statements
+                (VariableIdentifier)))))))
+    (TypeClass
+      (Empty)
+      (TypeClassIdentifier)
+      (TypeVariableIdentifier)
+      (Statements
+        (Context
+          (Comment)
+          (TypeSignature
+            (VariableIdentifier)
+            (FunctionType
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty))
+              (Type
+                (Array
+                  (Type
+                    (TypeConstructorIdentifier)
+                    (TypeParameters)
+                    (Empty)))
+                (TypeParameters)
+                (Empty)))))))
+    (TypeClass
+      (Empty)
+      (TypeClassIdentifier)
+      (TypeVariableIdentifier)
+      (Statements
+        (Function
+          (VariableIdentifier)
+          (Statements
+            (VariableIdentifier)))))
+    (Function
+      (VariableIdentifier)
+      (VariableIdentifier)
+      (Statements
+        (Match
+          (App
+            (VariableIdentifier)
+            (Empty)
+            (VariableIdentifier))
+          (Pattern
+            (ListPattern
+              (VariableIdentifier))
+            (App
+              (ConstructorIdentifier)
+              (Empty)
+              (VariableIdentifier))))))))
--- a/test/fixtures/haskell/corpus/layout.parseB.txt
+++ b/test/fixtures/haskell/corpus/layout.parseB.txt
@ -0,0 +1,113 @@
+(Module
+  (Empty)
+  (Statements
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Let
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Let
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (Integer)))
+                (VariableIdentifier))))
+          (VariableIdentifier))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (Statements
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Integer))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (Statements
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (Integer))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (Statements
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier)
+              (Statements
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (VariableIdentifier)))
+                (Function
+                  (VariableIdentifier)
+                  (Statements
+                    (VariableIdentifier))))))
+          (Function
+            (VariableIdentifier)
+            (Statements
+              (VariableIdentifier))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (VariableIdentifier)
+          (Do
+            (VariableIdentifier)
+            (VariableIdentifier)
+            (Do
+              (VariableIdentifier)
+              (VariableIdentifier))
+            (VariableIdentifier))
+          (VariableIdentifier))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (Statements
+            (Function
+              (VariableIdentifier)
+              (Statements
+                (VariableIdentifier)))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (Statements
+            (Function
+              (VariableIdentifier)
+              (Statements
+                (VariableIdentifier)))))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (Do
+          (VariableIdentifier)
+          (Statements
+            (Function
+              (VariableIdentifier)
+              (Statements
+                (VariableIdentifier)))))))))
--- a/test/fixtures/haskell/corpus/module-declaration3.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/module-declaration3.diffA-B.txt
@ -1,9 +1,7 @@
 (Module
-  (Empty)
-  (Statements
-    (QualifiedModuleIdentifier
-    { (ModuleIdentifier)
-    ->(ModuleIdentifier) }
-    { (ModuleIdentifier)
-    ->(ModuleIdentifier) })
-    (Statements)))
+  (QualifiedModuleIdentifier
+  { (ModuleIdentifier)
+  ->(ModuleIdentifier) }
+  { (ModuleIdentifier)
+  ->(ModuleIdentifier) })
+  (Statements))
--- a/test/fixtures/haskell/corpus/module-declaration3.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/module-declaration3.diffB-A.txt
@ -1,9 +1,7 @@
 (Module
-  (Empty)
-  (Statements
-    (QualifiedModuleIdentifier
-    { (ModuleIdentifier)
-    ->(ModuleIdentifier) }
-    { (ModuleIdentifier)
-    ->(ModuleIdentifier) })
-    (Statements)))
+  (QualifiedModuleIdentifier
+  { (ModuleIdentifier)
+  ->(ModuleIdentifier) }
+  { (ModuleIdentifier)
+  ->(ModuleIdentifier) })
+  (Statements))
--- a/test/fixtures/haskell/corpus/module-declaration3.parseA.txt
+++ b/test/fixtures/haskell/corpus/module-declaration3.parseA.txt
@ -1,7 +1,5 @@
 (Module
-  (Empty)
-  (Statements
-    (QualifiedModuleIdentifier
-      (ModuleIdentifier)
-      (ModuleIdentifier))
-    (Statements)))
+  (QualifiedModuleIdentifier
+    (ModuleIdentifier)
+    (ModuleIdentifier))
+  (Statements))
--- a/test/fixtures/haskell/corpus/module-declaration3.parseB.txt
+++ b/test/fixtures/haskell/corpus/module-declaration3.parseB.txt
@ -1,7 +1,5 @@
 (Module
-  (Empty)
-  (Statements
-    (QualifiedModuleIdentifier
-      (ModuleIdentifier)
-      (ModuleIdentifier))
-    (Statements)))
+  (QualifiedModuleIdentifier
+    (ModuleIdentifier)
+    (ModuleIdentifier))
+  (Statements))
--- a/test/fixtures/haskell/corpus/newtype-declaration.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/newtype-declaration.diffA-B.txt
@ -8,8 +8,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Empty))
    (NewType
      (Context'
@ -22,8 +21,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Empty))
    (NewType
      (Statements
@ -32,17 +30,16 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (Statements
-            (Field
-              (Statements
-              { (VariableIdentifier)
-              ->(VariableIdentifier) })
-              (Type
-                (TypeConstructorIdentifier)
-                (TypeParameters
-                  (TypeConstructorIdentifier))
-                (Empty))))))
+        (Statements
+          (Field
+            (Statements
+            { (VariableIdentifier)
+            ->(VariableIdentifier) })
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters
+                (TypeConstructorIdentifier))
+              (Empty)))))
      (Empty))
    (NewType
      (Statements
@ -61,11 +58,10 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (Statements
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier))))
+        (Statements
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)))
      (Empty))
    (NewType
      (Statements
@ -74,8 +70,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Deriving
        (TypeClassIdentifier)))
    (NewType
@ -85,8 +80,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Deriving
        (TypeClassIdentifier)
        (TypeClassIdentifier)
--- a/test/fixtures/haskell/corpus/newtype-declaration.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/newtype-declaration.diffB-A.txt
@ -8,8 +8,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Empty))
    (NewType
      (Context'
@ -22,8 +21,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Empty))
    (NewType
      (Statements
@ -32,17 +30,16 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (Statements
-            (Field
-              (Statements
-              { (VariableIdentifier)
-              ->(VariableIdentifier) })
-              (Type
-                (TypeConstructorIdentifier)
-                (TypeParameters
-                  (TypeConstructorIdentifier))
-                (Empty))))))
+        (Statements
+          (Field
+            (Statements
+            { (VariableIdentifier)
+            ->(VariableIdentifier) })
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters
+                (TypeConstructorIdentifier))
+              (Empty)))))
      (Empty))
    (NewType
      (Statements
@ -61,11 +58,10 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (Statements
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier))))
+        (Statements
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)))
      (Empty))
    (NewType
      (Statements
@ -74,8 +70,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Deriving
        (TypeClassIdentifier)))
    (NewType
@ -85,8 +80,7 @@
      (Constructor
      { (ConstructorIdentifier)
      ->(ConstructorIdentifier) }
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Deriving
        (TypeClassIdentifier)
        (TypeClassIdentifier)
--- a/test/fixtures/haskell/corpus/newtype-declaration.parseA.txt
+++ b/test/fixtures/haskell/corpus/newtype-declaration.parseA.txt
@ -6,8 +6,7 @@
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Empty))
    (NewType
      (Context'
@ -18,24 +17,22 @@
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Empty))
    (NewType
      (Statements
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (Statements
-            (Field
-              (Statements
-                (VariableIdentifier))
-              (Type
-                (TypeConstructorIdentifier)
-                (TypeParameters
-                  (TypeConstructorIdentifier))
-                (Empty))))))
+        (Statements
+          (Field
+            (Statements
+              (VariableIdentifier))
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters
+                (TypeConstructorIdentifier))
+              (Empty)))))
      (Empty))
    (NewType
      (Statements
@ -52,19 +49,17 @@
        (TypeVariableIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (Statements
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier))))
+        (Statements
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)))
      (Empty))
    (NewType
      (Statements
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Deriving
        (TypeClassIdentifier)))
    (NewType
@ -72,8 +67,7 @@
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Deriving
        (TypeClassIdentifier)
        (TypeClassIdentifier)
--- a/test/fixtures/haskell/corpus/newtype-declaration.parseB.txt
+++ b/test/fixtures/haskell/corpus/newtype-declaration.parseB.txt
@ -6,8 +6,7 @@
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Empty))
    (NewType
      (Context'
@ -18,24 +17,22 @@
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Empty))
    (NewType
      (Statements
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (Statements
-            (Field
-              (Statements
-                (VariableIdentifier))
-              (Type
-                (TypeConstructorIdentifier)
-                (TypeParameters
-                  (TypeConstructorIdentifier))
-                (Empty))))))
+        (Statements
+          (Field
+            (Statements
+              (VariableIdentifier))
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters
+                (TypeConstructorIdentifier))
+              (Empty)))))
      (Empty))
    (NewType
      (Statements
@ -52,19 +49,17 @@
        (TypeVariableIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (Statements
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier)
-            (TypeVariableIdentifier))))
+        (Statements
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)))
      (Empty))
    (NewType
      (Statements
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeConstructorIdentifier)))
+        (TypeConstructorIdentifier))
      (Deriving
        (TypeClassIdentifier)))
    (NewType
@ -72,8 +67,7 @@
        (TypeConstructorIdentifier))
      (Constructor
        (ConstructorIdentifier)
-        (TypeParameters
-          (TypeVariableIdentifier)))
+        (TypeVariableIdentifier))
      (Deriving
        (TypeClassIdentifier)
        (TypeClassIdentifier)
--- a/test/fixtures/haskell/corpus/statements.A.hs
+++ b/test/fixtures/haskell/corpus/statements.A.hs
@ -2,3 +2,7 @@ f = if a then 1 else 2
 f = if a; then b; else c
 f = if (if a then b else c) then d else e
 f = if if a then b else c then d else e
+
+head' :: [a] -> a
+head' [] = error "No head for empty lists!"
+head' (x:_) = x
--- a/test/fixtures/haskell/corpus/statements.B.hs
+++ b/test/fixtures/haskell/corpus/statements.B.hs
@ -2,3 +2,7 @@ g = if b then 1 else 2
 g = if b; then c; else d
 g = if (if b then c else d) then e else f
 g = if if b then c else d then e else f
+
+h' :: [a] -> a
+h' [] = error "No head for empty lists!"
+h' (x:_) = x
--- a/test/fixtures/haskell/corpus/statements.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/statements.diffA-B.txt
@ -52,4 +52,39 @@
        { (VariableIdentifier)
        ->(VariableIdentifier) }
        { (VariableIdentifier)
-        ->(VariableIdentifier) })))))
+        ->(VariableIdentifier) })))
+    (TypeSignature
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (FunctionType
+        (Type
+          (Array
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty)))
+          (TypeParameters)
+          (Empty))
+        (Type
+          (TypeVariableIdentifier)
+          (TypeParameters)
+          (Empty))))
+    (Function
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (ListConstructor)
+      (Statements
+        (App
+          (VariableIdentifier)
+          (Empty)
+          (TextElement))))
+    (Function
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (Statements
+        (VariableIdentifier)
+        (ConstructorOperator
+          (ConstructorSymbol))
+        (Wildcard))
+      (Statements
+        (VariableIdentifier)))))
--- a/test/fixtures/haskell/corpus/statements.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/statements.diffB-A.txt
@ -52,4 +52,39 @@
        { (VariableIdentifier)
        ->(VariableIdentifier) }
        { (VariableIdentifier)
-        ->(VariableIdentifier) })))))
+        ->(VariableIdentifier) })))
+    (TypeSignature
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (FunctionType
+        (Type
+          (Array
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty)))
+          (TypeParameters)
+          (Empty))
+        (Type
+          (TypeVariableIdentifier)
+          (TypeParameters)
+          (Empty))))
+    (Function
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (ListConstructor)
+      (Statements
+        (App
+          (VariableIdentifier)
+          (Empty)
+          (TextElement))))
+    (Function
+    { (VariableIdentifier)
+    ->(VariableIdentifier) }
+      (Statements
+        (VariableIdentifier)
+        (ConstructorOperator
+          (ConstructorSymbol))
+        (Wildcard))
+      (Statements
+        (VariableIdentifier)))))
--- a/test/fixtures/haskell/corpus/statements.parseA.txt
+++ b/test/fixtures/haskell/corpus/statements.parseA.txt
@ -34,4 +34,36 @@
            (VariableIdentifier)
            (VariableIdentifier))
          (VariableIdentifier)
-          (VariableIdentifier))))))
+          (VariableIdentifier))))
+    (TypeSignature
+      (VariableIdentifier)
+      (FunctionType
+        (Type
+          (Array
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty)))
+          (TypeParameters)
+          (Empty))
+        (Type
+          (TypeVariableIdentifier)
+          (TypeParameters)
+          (Empty))))
+    (Function
+      (VariableIdentifier)
+      (ListConstructor)
+      (Statements
+        (App
+          (VariableIdentifier)
+          (Empty)
+          (TextElement))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (ConstructorOperator
+          (ConstructorSymbol))
+        (Wildcard))
+      (Statements
+        (VariableIdentifier)))))
--- a/test/fixtures/haskell/corpus/statements.parseB.txt
+++ b/test/fixtures/haskell/corpus/statements.parseB.txt
@ -34,4 +34,36 @@
            (VariableIdentifier)
            (VariableIdentifier))
          (VariableIdentifier)
-          (VariableIdentifier))))))
+          (VariableIdentifier))))
+    (TypeSignature
+      (VariableIdentifier)
+      (FunctionType
+        (Type
+          (Array
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty)))
+          (TypeParameters)
+          (Empty))
+        (Type
+          (TypeVariableIdentifier)
+          (TypeParameters)
+          (Empty))))
+    (Function
+      (VariableIdentifier)
+      (ListConstructor)
+      (Statements
+        (App
+          (VariableIdentifier)
+          (Empty)
+          (TextElement))))
+    (Function
+      (VariableIdentifier)
+      (Statements
+        (VariableIdentifier)
+        (ConstructorOperator
+          (ConstructorSymbol))
+        (Wildcard))
+      (Statements
+        (VariableIdentifier)))))
--- a/test/fixtures/haskell/corpus/tempate-haskell.parseA.txt
+++ b/test/fixtures/haskell/corpus/tempate-haskell.parseA.txt
@ -71,6 +71,7 @@
          (QuasiQuotation
            (Empty)
            (QuasiQuotationExpressionBody))
+          (Empty)
          (VariableOperator
            (InfixVariableIdentifier))
          (VariableIdentifier))))
@ -85,16 +86,19 @@
        (Splice
          (InfixOperatorApp
            (VariableIdentifier)
+            (Empty)
            (VariableOperator
              (VariableSymbol))
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (VariableIdentifier))))))
    (Splice
      (App
        (VariableIdentifier)
+        (Empty)
        (QuotedName
          (QuotedName
            (TypeConstructorIdentifier)))))))
--- a/test/fixtures/haskell/corpus/type-class-declarations.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/type-class-declarations.diffA-B.txt
@ -7,499 +7,290 @@
    ->(TypeClassIdentifier) }
      (TypeVariableIdentifier)
      (Statements))
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Class
-        {+(TypeClassIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Statements
-        {+(Class
-          {+(TypeClassIdentifier)+}
-          {+(TypeVariableIdentifier)+})+}
-        {+(Class
-          {+(TypeClassIdentifier)+}
-          {+(TypeVariableIdentifier)+})+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(Context'
-          {+(Class
-            {+(TypeClassIdentifier)+}
-            {+(TypeVariableIdentifier)+})+})+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(Context'
-          {+(Statements
-            {+(Class
-              {+(TypeClassIdentifier)+}
-              {+(TypeVariableIdentifier)+})+}
-            {+(Class
-              {+(TypeClassIdentifier)+}
-              {+(TypeVariableIdentifier)+})+})+})+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+})+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(Fixity'
-        {+(Empty)+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+})+}
-      {+(Fixity'
-        {+(Empty)+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(ConstructorOperator
-          {+(ConstructorSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(ConstructorOperator
-          {+(ConstructorSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(ConstructorOperator
-          {+(ConstructorSymbol)+})+})+})+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Class
-        {+(TypeClassIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeConstructorIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeConstructorIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Class
-        {+(TypeClassIdentifier)+}
-        {+(TypeVariableIdentifier)+}
-        {+(TypeVariableIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(Type
-            {+(TypeConstructorIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+})+})+}
-      {+(DefaultSignature
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(Type
-            {+(TypeConstructorIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+})+})+})+})+}
    (TypeClass
      (Empty)
    { (TypeClassIdentifier)
    ->(TypeClassIdentifier) }
-    {+(AnnotatedTypeVariable
-      {+(TypeVariableIdentifier)+}
-      {+(TypeConstructorIdentifier)+})+}
-    {-(TypeVariableIdentifier)-}
-    {-(TypeVariableIdentifier)-}
+      (TypeVariableIdentifier)
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Context'
+        (Class
+        { (TypeClassIdentifier)
+        ->(TypeClassIdentifier) }
+          (TypeVariableIdentifier)))
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Context'
+        (Statements
+          (Class
+            (TypeClassIdentifier)
+            (TypeVariableIdentifier))
+          (Class
+            (TypeClassIdentifier)
+            (TypeVariableIdentifier))))
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements
+        (TypeSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (Context'
+            (Class
+              (TypeClassIdentifier)
+              (TypeVariableIdentifier)))
+          (FunctionType
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (Context'
+            (Statements
+              (Class
+                (TypeClassIdentifier)
+                (TypeVariableIdentifier))
+              (Class
+                (TypeClassIdentifier)
+                (TypeVariableIdentifier))))
+          (FunctionType
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty)))))))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements
+        (Fixity'
+          (Empty)
+          (VariableOperator
+            (InfixVariableIdentifier)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (VariableOperator
+            (InfixVariableIdentifier)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (VariableOperator
+            (InfixVariableIdentifier))
+          (VariableOperator
+            (InfixVariableIdentifier))
+          (VariableOperator
+            (InfixVariableIdentifier)))
+        (Fixity'
+          (Empty)
+          (VariableOperator
+            (VariableSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (VariableOperator
+            (VariableSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (ConstructorOperator
+            (ConstructorSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (ConstructorOperator
+            (ConstructorSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (ConstructorOperator
+            (ConstructorSymbol)))))
+    (TypeClass
+      (Context'
+        (Class
+          (TypeClassIdentifier)
+        { (TypeVariableIdentifier)
+        ->(TypeVariableIdentifier) }))
+      (TypeClassIdentifier)
+    { (TypeVariableIdentifier)
+    ->(TypeVariableIdentifier) }
+      (Statements
+        (TypeSignature
+          (VariableIdentifier)
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeConstructorIdentifier)
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+          (VariableOperator
+            (VariableSymbol))
+          (VariableOperator
+            (VariableSymbol))
+          (VariableOperator
+            (VariableSymbol))
+          (VariableOperator
+            (VariableSymbol))
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeConstructorIdentifier)
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+          (VariableIdentifier)
+          (VariableIdentifier)
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty))
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+          (VariableIdentifier)
+        { (TypeVariableIdentifier)
+        ->(TypeVariableIdentifier) })))
+    (TypeClass
+      (Context'
+        (Class
+        { (TypeClassIdentifier)
+        ->(TypeClassIdentifier) }
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)))
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (TypeVariableIdentifier)
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+    { (TypeVariableIdentifier)
+    ->(TypeVariableIdentifier) }
+      (Statements
+        (TypeSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters)
+              (Empty))))
+        (DefaultSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters)
+              (Empty))))))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (AnnotatedTypeVariable
+        (TypeVariableIdentifier)
+      { (TypeConstructorIdentifier)
+      ->(TypeConstructorIdentifier) })
+      (Statements))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (AnnotatedTypeVariable
+      { (TypeVariableIdentifier)
+      ->(TypeVariableIdentifier) }
+        (KindFunctionType
+          (Kind
+            (KindListType
+              (KindFunctionType
+                (Kind
+                  (Star))
+                (Kind
+                  (Star)))))
+          (KindFunctionType
+            (Kind
+              (Star))
+            (Kind
+              (Star)))))
      (Statements))
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(AnnotatedTypeVariable
-      {+(TypeVariableIdentifier)+}
-      {+(KindFunctionType
-        {+(Kind
-          {+(KindListType
-            {+(KindFunctionType
-              {+(Kind
-                {+(Star)+})+}
-              {+(Kind
-                {+(Star)+})+})+})+})+}
-        {+(KindFunctionType
-          {+(Kind
-            {+(Star)+})+}
-          {+(Kind
-            {+(Star)+})+})+})+})+}
-    {+(Statements)+})+}
-  {-(TypeClass
-    {-(Context'
-      {-(Class
-        {-(TypeClassIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Context'
-      {-(Statements
-        {-(Class
-          {-(TypeClassIdentifier)-}
-          {-(TypeVariableIdentifier)-})-}
-        {-(Class
-          {-(TypeClassIdentifier)-}
-          {-(TypeVariableIdentifier)-})-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(Context'
-          {-(Class
-            {-(TypeClassIdentifier)-}
-            {-(TypeVariableIdentifier)-})-})-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(Context'
-          {-(Statements
-            {-(Class
-              {-(TypeClassIdentifier)-}
-              {-(TypeVariableIdentifier)-})-}
-            {-(Class
-              {-(TypeClassIdentifier)-}
-              {-(TypeVariableIdentifier)-})-})-})-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-})-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(Fixity'
-        {-(Empty)-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-})-}
-      {-(Fixity'
-        {-(Empty)-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(ConstructorOperator
-          {-(ConstructorSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(ConstructorOperator
-          {-(ConstructorSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(ConstructorOperator
-          {-(ConstructorSymbol)-})-})-})-})-}
-  {-(TypeClass
-    {-(Context'
-      {-(Class
-        {-(TypeClassIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeConstructorIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeConstructorIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-})-}
-  {-(TypeClass
-    {-(Context'
-      {-(Class
-        {-(TypeClassIdentifier)-}
-        {-(TypeVariableIdentifier)-}
-        {-(TypeVariableIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(Type
-            {-(TypeConstructorIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-})-})-}
-      {-(DefaultSignature
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(Type
-            {-(TypeConstructorIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-})-})-})-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(AnnotatedTypeVariable
-      {-(TypeVariableIdentifier)-}
-      {-(TypeConstructorIdentifier)-})-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(AnnotatedTypeVariable
-      {-(TypeVariableIdentifier)-}
-      {-(KindFunctionType
-        {-(Kind
-          {-(KindListType
-            {-(KindFunctionType
-              {-(Kind
-                {-(Star)-})-}
-              {-(Kind
-                {-(Star)-})-})-})-})-}
-        {-(KindFunctionType
-          {-(Kind
-            {-(Star)-})-}
-          {-(Kind
-            {-(Star)-})-})-})-})-}
-    {-(Statements)-})-}
    (TypeClass
      (Empty)
      (TypeClassIdentifier)
--- a/test/fixtures/haskell/corpus/type-class-declarations.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/type-class-declarations.diffB-A.txt
@ -7,502 +7,290 @@
    ->(TypeClassIdentifier) }
      (TypeVariableIdentifier)
      (Statements))
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Class
-        {+(TypeClassIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Statements
-        {+(Class
-          {+(TypeClassIdentifier)+}
-          {+(TypeVariableIdentifier)+})+}
-        {+(Class
-          {+(TypeClassIdentifier)+}
-          {+(TypeVariableIdentifier)+})+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(Context'
-          {+(Class
-            {+(TypeClassIdentifier)+}
-            {+(TypeVariableIdentifier)+})+})+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(Context'
-          {+(Statements
-            {+(Class
-              {+(TypeClassIdentifier)+}
-              {+(TypeVariableIdentifier)+})+}
-            {+(Class
-              {+(TypeClassIdentifier)+}
-              {+(TypeVariableIdentifier)+})+})+})+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+})+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(Fixity'
-        {+(Empty)+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+}
-        {+(VariableOperator
-          {+(InfixVariableIdentifier)+})+})+}
-      {+(Fixity'
-        {+(Empty)+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(ConstructorOperator
-          {+(ConstructorSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(ConstructorOperator
-          {+(ConstructorSymbol)+})+})+}
-      {+(Fixity'
-        {+(Integer)+}
-        {+(ConstructorOperator
-          {+(ConstructorSymbol)+})+})+})+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Class
-        {+(TypeClassIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeConstructorIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(VariableOperator
-          {+(VariableSymbol)+})+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeConstructorIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(FunctionType
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+}
-            {+(Type
-              {+(TypeVariableIdentifier)+}
-              {+(TypeParameters)+}
-              {+(Empty)+})+})+})+})+}
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+})+}
-  {+(TypeClass
-    {+(Context'
-      {+(Class
-        {+(TypeClassIdentifier)+}
-        {+(TypeVariableIdentifier)+}
-        {+(TypeVariableIdentifier)+}
-        {+(TypeVariableIdentifier)+})+})+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(TypeVariableIdentifier)+}
-    {+(Statements
-      {+(TypeSignature
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(Type
-            {+(TypeConstructorIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+})+})+}
-      {+(DefaultSignature
-        {+(VariableIdentifier)+}
-        {+(FunctionType
-          {+(Type
-            {+(TypeVariableIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+}
-          {+(Type
-            {+(TypeConstructorIdentifier)+}
-            {+(TypeParameters)+}
-            {+(Empty)+})+})+})+})+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(AnnotatedTypeVariable
-      {+(TypeVariableIdentifier)+}
-      {+(TypeConstructorIdentifier)+})+}
-    {+(Statements)+})+}
-  {+(TypeClass
-    {+(Empty)+}
-    {+(TypeClassIdentifier)+}
-    {+(AnnotatedTypeVariable
-      {+(TypeVariableIdentifier)+}
-      {+(KindFunctionType
-        {+(Kind
-          {+(KindListType
-            {+(KindFunctionType
-              {+(Kind
-                {+(Star)+})+}
-              {+(Kind
-                {+(Star)+})+})+})+})+}
-        {+(KindFunctionType
-          {+(Kind
-            {+(Star)+})+}
-          {+(Kind
-            {+(Star)+})+})+})+})+}
-    {+(Statements)+})+}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Context'
-      {-(Class
-        {-(TypeClassIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Context'
-      {-(Statements
-        {-(Class
-          {-(TypeClassIdentifier)-}
-          {-(TypeVariableIdentifier)-})-}
-        {-(Class
-          {-(TypeClassIdentifier)-}
-          {-(TypeVariableIdentifier)-})-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(Context'
-          {-(Class
-            {-(TypeClassIdentifier)-}
-            {-(TypeVariableIdentifier)-})-})-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(Context'
-          {-(Statements
-            {-(Class
-              {-(TypeClassIdentifier)-}
-              {-(TypeVariableIdentifier)-})-}
-            {-(Class
-              {-(TypeClassIdentifier)-}
-              {-(TypeVariableIdentifier)-})-})-})-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-})-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(Fixity'
-        {-(Empty)-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-}
-        {-(VariableOperator
-          {-(InfixVariableIdentifier)-})-})-}
-      {-(Fixity'
-        {-(Empty)-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(ConstructorOperator
-          {-(ConstructorSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(ConstructorOperator
-          {-(ConstructorSymbol)-})-})-}
-      {-(Fixity'
-        {-(Integer)-}
-        {-(ConstructorOperator
-          {-(ConstructorSymbol)-})-})-})-})-}
-  {-(TypeClass
-    {-(Context'
-      {-(Class
-        {-(TypeClassIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeConstructorIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(VariableOperator
-          {-(VariableSymbol)-})-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeConstructorIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(FunctionType
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-}
-            {-(Type
-              {-(TypeVariableIdentifier)-}
-              {-(TypeParameters)-}
-              {-(Empty)-})-})-})-})-}
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-})-}
-  {-(TypeClass
-    {-(Context'
-      {-(Class
-        {-(TypeClassIdentifier)-}
-        {-(TypeVariableIdentifier)-}
-        {-(TypeVariableIdentifier)-}
-        {-(TypeVariableIdentifier)-})-})-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(TypeVariableIdentifier)-}
-    {-(Statements
-      {-(TypeSignature
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(Type
-            {-(TypeConstructorIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-})-})-}
-      {-(DefaultSignature
-        {-(VariableIdentifier)-}
-        {-(FunctionType
-          {-(Type
-            {-(TypeVariableIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-}
-          {-(Type
-            {-(TypeConstructorIdentifier)-}
-            {-(TypeParameters)-}
-            {-(Empty)-})-})-})-})-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(AnnotatedTypeVariable
-      {-(TypeVariableIdentifier)-}
-      {-(TypeConstructorIdentifier)-})-}
-    {-(Statements)-})-}
-  {-(TypeClass
-    {-(Empty)-}
-    {-(TypeClassIdentifier)-}
-    {-(AnnotatedTypeVariable
-      {-(TypeVariableIdentifier)-}
-      {-(KindFunctionType
-        {-(Kind
-          {-(KindListType
-            {-(KindFunctionType
-              {-(Kind
-                {-(Star)-})-}
-              {-(Kind
-                {-(Star)-})-})-})-})-}
-        {-(KindFunctionType
-          {-(Kind
-            {-(Star)-})-}
-          {-(Kind
-            {-(Star)-})-})-})-})-}
-    {-(Statements)-})-}
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Context'
+        (Class
+        { (TypeClassIdentifier)
+        ->(TypeClassIdentifier) }
+          (TypeVariableIdentifier)))
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Context'
+        (Statements
+          (Class
+            (TypeClassIdentifier)
+            (TypeVariableIdentifier))
+          (Class
+            (TypeClassIdentifier)
+            (TypeVariableIdentifier))))
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements
+        (TypeSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (Context'
+            (Class
+              (TypeClassIdentifier)
+              (TypeVariableIdentifier)))
+          (FunctionType
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (Context'
+            (Statements
+              (Class
+                (TypeClassIdentifier)
+                (TypeVariableIdentifier))
+              (Class
+                (TypeClassIdentifier)
+                (TypeVariableIdentifier))))
+          (FunctionType
+            (Type
+              (TypeVariableIdentifier)
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeVariableIdentifier)
+                (TypeParameters)
+                (Empty)))))))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (Statements
+        (Fixity'
+          (Empty)
+          (VariableOperator
+            (InfixVariableIdentifier)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (VariableOperator
+            (InfixVariableIdentifier)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (VariableOperator
+            (InfixVariableIdentifier))
+          (VariableOperator
+            (InfixVariableIdentifier))
+          (VariableOperator
+            (InfixVariableIdentifier)))
+        (Fixity'
+          (Empty)
+          (VariableOperator
+            (VariableSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (VariableOperator
+            (VariableSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (ConstructorOperator
+            (ConstructorSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (ConstructorOperator
+            (ConstructorSymbol)))
+        (Fixity'
+        { (Integer)
+        ->(Integer) }
+          (ConstructorOperator
+            (ConstructorSymbol)))))
+    (TypeClass
+      (Context'
+        (Class
+          (TypeClassIdentifier)
+        { (TypeVariableIdentifier)
+        ->(TypeVariableIdentifier) }))
+      (TypeClassIdentifier)
+    { (TypeVariableIdentifier)
+    ->(TypeVariableIdentifier) }
+      (Statements
+        (TypeSignature
+          (VariableIdentifier)
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeConstructorIdentifier)
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+          (VariableOperator
+            (VariableSymbol))
+          (VariableOperator
+            (VariableSymbol))
+          (VariableOperator
+            (VariableSymbol))
+          (VariableOperator
+            (VariableSymbol))
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty))
+              (Type
+                (TypeConstructorIdentifier)
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+          (VariableIdentifier)
+          (VariableIdentifier)
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (FunctionType
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty))
+              (Type
+              { (TypeVariableIdentifier)
+              ->(TypeVariableIdentifier) }
+                (TypeParameters)
+                (Empty)))))
+        (TypeSignature
+          (VariableIdentifier)
+        { (TypeVariableIdentifier)
+        ->(TypeVariableIdentifier) })))
+    (TypeClass
+      (Context'
+        (Class
+        { (TypeClassIdentifier)
+        ->(TypeClassIdentifier) }
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)
+          (TypeVariableIdentifier)))
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (TypeVariableIdentifier)
+      (TypeVariableIdentifier)
+      (TypeVariableIdentifier)
+      (Statements))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+    { (TypeVariableIdentifier)
+    ->(TypeVariableIdentifier) }
+      (Statements
+        (TypeSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters)
+              (Empty))))
+        (DefaultSignature
+        { (VariableIdentifier)
+        ->(VariableIdentifier) }
+          (FunctionType
+            (Type
+            { (TypeVariableIdentifier)
+            ->(TypeVariableIdentifier) }
+              (TypeParameters)
+              (Empty))
+            (Type
+              (TypeConstructorIdentifier)
+              (TypeParameters)
+              (Empty))))))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (AnnotatedTypeVariable
+        (TypeVariableIdentifier)
+      { (TypeConstructorIdentifier)
+      ->(TypeConstructorIdentifier) })
+      (Statements))
+    (TypeClass
+      (Empty)
+    { (TypeClassIdentifier)
+    ->(TypeClassIdentifier) }
+      (AnnotatedTypeVariable
+      { (TypeVariableIdentifier)
+      ->(TypeVariableIdentifier) }
+        (KindFunctionType
+          (Kind
+            (KindListType
+              (KindFunctionType
+                (Kind
+                  (Star))
+                (Kind
+                  (Star)))))
+          (KindFunctionType
+            (Kind
+              (Star))
+            (Kind
+              (Star)))))
+      (Statements))
    (TypeClass
      (Empty)
      (TypeClassIdentifier)
--- a/test/fixtures/haskell/corpus/type-class-instance-declarations.diffA-B.txt
+++ b/test/fixtures/haskell/corpus/type-class-instance-declarations.diffA-B.txt
--- a/test/fixtures/haskell/corpus/type-class-instance-declarations.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/type-class-instance-declarations.diffB-A.txt
--- a/test/fixtures/haskell/corpus/type-class-instance-declarations.parseA.txt
+++ b/test/fixtures/haskell/corpus/type-class-instance-declarations.parseA.txt
@ -609,8 +609,10 @@
          (Statements
            (App
              (ConstructorIdentifier)
+              (Empty)
              (InfixOperatorApp
                (VariableIdentifier)
+                (Empty)
                (VariableOperator
                  (VariableSymbol))
                (VariableIdentifier)))))))
@ -709,6 +711,7 @@
          (Statements
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (ConstructorIdentifier))))))
--- a/test/fixtures/haskell/corpus/type-class-instance-declarations.parseB.txt
+++ b/test/fixtures/haskell/corpus/type-class-instance-declarations.parseB.txt
@ -609,8 +609,10 @@
          (Statements
            (App
              (ConstructorIdentifier)
+              (Empty)
              (InfixOperatorApp
                (VariableIdentifier)
+                (Empty)
                (VariableOperator
                  (VariableSymbol))
                (VariableIdentifier)))))))
@ -709,6 +711,7 @@
          (Statements
            (InfixOperatorApp
              (VariableIdentifier)
+              (Empty)
              (VariableOperator
                (VariableSymbol))
              (ConstructorIdentifier))))))
--- a/test/fixtures/haskell/corpus/type-synonyms.diffB-A.txt
+++ b/test/fixtures/haskell/corpus/type-synonyms.diffB-A.txt
@ -115,14 +115,11 @@
                {+(TypeConstructorIdentifier)+}
                {+(TypeVariableIdentifier)+})+})+}
            {+(Empty)+})+})+})+})+})+}
-    (TypeSynonym
-      (Statements
-      { (TypeConstructorIdentifier)
-      ->(TypeConstructorIdentifier) }
-      {+(TypeConstructorIdentifier)+})
-    { (TypePattern
-      {-(FunctionConstructor)-})
-    ->(TextElement) })
+  {+(TypeSynonym
+    {+(Statements
+      {+(TypeConstructorIdentifier)+}
+      {+(TypeConstructorIdentifier)+})+}
+    {+(TextElement)+})+}
  {+(TypeSynonym
    {+(Statements
      {+(TypeConstructorIdentifier)+}
@ -171,6 +168,11 @@
          {+(TypeConstructorIdentifier)+}
          {+(TypeVariableIdentifier)+}
          {+(TypeVariableIdentifier)+})+})+})+})+}
+  {-(TypeSynonym
+    {-(Statements
+      {-(TypeConstructorIdentifier)-})-}
+    {-(TypePattern
+      {-(FunctionConstructor)-})-})-}
  {-(TypeSynonym
    {-(Statements
      {-(TypeConstructorIdentifier)-})-}
--- a/vendor/haskell-tree-sitter
+++ b/vendor/haskell-tree-sitter
@ -1 +1 @@
-Subproject commit 643f8a2856f9d9a4cf25f3b0eb844aa46aafc535
+Subproject commit 6176c8c8e7c59760a881a2487d81bcbdb26efe9c