github/semantic
1
1
Fork 0
mirror of https://github.com/github/semantic.git synced 2024-12-21 13:51:44 +03:00
Code Issues Projects Releases Wiki Activity
2e3713db34
semantic/test/fixtures/haskell/corpus/function-declarations.diffB-A.txt

2243 lines
65 KiB
Plaintext
Raw Normal View History

Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
(Module
(Empty)
(Statements
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(Integer)+})+})+}
{+(Statements
{+(App
{+(ConstructorIdentifier)+}
{+(Empty)+}
{+(Integer)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(AsPattern
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+}
{+(AsPattern
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Wildcard)+}
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Integer)+}
{+(Integer)+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(TextElement)+}
{+(TextElement)+}
{+(Statements
{+(TextElement)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Character)+}
{+(Character)+}
{+(Statements
{+(Character)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Float)+}
{+(Float)+}
{+(Statements
{+(Float)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(FieldPattern
{+(VariableIdentifier)+}
{+(Integer)+})+})+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(FieldPattern
{+(VariableIdentifier)+}
{+(Integer)+})+}
{+(FieldPattern
{+(VariableIdentifier)+}
{+(Integer)+})+})+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(ConstructorIdentifier)+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(NamedFieldPun
{+(VariableIdentifier)+})+}
{+(NamedFieldPun
{+(VariableIdentifier)+})+})+})+}
{+(Statements
{+(Array
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(RecordWildCards)+})+})+}
{+(Statements
{+(Array
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(NamedFieldPun
{+(VariableIdentifier)+})+}
{+(FieldPattern
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+}
{+(RecordWildCards)+})+})+}
{+(Statements
{+(Array
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Integer)+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(NegativeLiteral
{+(Integer)+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(ListConstructor)+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(TuplePattern
{+(Integer)+}
{+(Integer)+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(TuplePattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(Integer)+})+})+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(Integer)+})+})+})+}
{+(Statements
{+(App
{+(ConstructorIdentifier)+}
{+(Empty)+}
{+(Integer)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(TuplePattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(ConstructorIdentifier)+})+}
{+(Statements
{+(ConstructorIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(TuplePattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(NegativeLiteral
{+(Integer)+})+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(ListConstructor)+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(ListPattern
{+(VariableIdentifier)+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(IrrefutablePattern
{+(VariableIdentifier)+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(IrrefutablePattern
{+(NegativeLiteral
{+(Integer)+})+})+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(IrrefutablePattern
{+(TuplePattern
{+(IrrefutablePattern
{+(TuplePattern
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(VariableIdentifier)+})+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(Match
{+(VariableIdentifier)+}
{+(Pattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(Statements
{+(CaseGuardPattern
{+(Guard
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Integer)+})+})+}
{+(ConstructorIdentifier)+})+}
{+(CaseGuardPattern
{+(Guard
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Integer)+})+})+}
{+(ConstructorIdentifier)+})+}
{+(CaseGuardPattern
{+(Guard
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Integer)+})+})+}
{+(ConstructorIdentifier)+})+})+})+})+})+})+}
(Function
(VariableIdentifier)
{ (VariableIdentifier)
->(VariableIdentifier) }
{-(VariableIdentifier)-}
(Statements
{+(Match
{+(VariableIdentifier)+}
{+(Statements
{+(Pattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(CaseGuardPattern
{+(Guard
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Integer)+})+})+}
{+(Guard
{+(ConstructorIdentifier)+})+}
{+(Guard
{+(Let
{+(TypeSignature
{+(VariableIdentifier)+}
{+(FunctionType
{+(Type
{+(TypeConstructorIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+}
{+(Type
{+(TypeConstructorIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Empty)+})+})+}
{+(ConstructorIdentifier)+})+})+}
{+(Pattern
{+(ConstructorIdentifier)+}
{+(ConstructorIdentifier)+})+})+})+}
{-(VariableIdentifier)-}))
{-(Function
{-(VariableIdentifier)-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(Integer)-})-})-}
{-(Statements
{-(App
{-(ConstructorIdentifier)-}
{-(Empty)-}
{-(Integer)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(AsPattern
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-}
{-(AsPattern
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Wildcard)-}
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Integer)-}
{-(Integer)-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(TextElement)-}
{-(TextElement)-}
{-(Statements
{-(TextElement)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Character)-}
{-(Character)-}
{-(Statements
{-(Character)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Float)-}
{-(Float)-}
{-(Statements
{-(Float)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(FieldPattern
{-(VariableIdentifier)-}
{-(Integer)-})-})-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(FieldPattern
{-(VariableIdentifier)-}
{-(Integer)-})-}
{-(FieldPattern
{-(VariableIdentifier)-}
{-(Integer)-})-})-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(ConstructorIdentifier)-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(NamedFieldPun
{-(VariableIdentifier)-})-}
{-(NamedFieldPun
{-(VariableIdentifier)-})-})-})-}
{-(Statements
{-(Array
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(RecordWildCards)-})-})-}
{-(Statements
{-(Array
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(NamedFieldPun
{-(VariableIdentifier)-})-}
{-(FieldPattern
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-}
{-(RecordWildCards)-})-})-}
{-(Statements
{-(Array
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(AsPattern
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(FieldPattern
{-(VariableIdentifier)-}
{-(Integer)-})-})-})-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Integer)-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(NegativeLiteral
{-(Integer)-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(ListConstructor)-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(TuplePattern
{-(Integer)-}
{-(Integer)-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(TuplePattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(Integer)-})-})-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(Integer)-})-})-})-}
{-(Statements
{-(App
{-(ConstructorIdentifier)-}
{-(Empty)-}
{-(Integer)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(TuplePattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(ConstructorIdentifier)-})-}
{-(Statements
{-(ConstructorIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(TuplePattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(NegativeLiteral
{-(Integer)-})-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(ListConstructor)-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(ListPattern
{-(VariableIdentifier)-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(IrrefutablePattern
{-(VariableIdentifier)-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(IrrefutablePattern
{-(NegativeLiteral
{-(Integer)-})-})-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(IrrefutablePattern
{-(TuplePattern
{-(IrrefutablePattern
{-(TuplePattern
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(VariableIdentifier)-})-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(Match
{-(VariableIdentifier)-}
{-(Pattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(Statements
{-(CaseGuardPattern
{-(Guard
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Integer)-})-})-}
{-(ConstructorIdentifier)-})-}
{-(CaseGuardPattern
{-(Guard
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Integer)-})-})-}
{-(ConstructorIdentifier)-})-}
{-(CaseGuardPattern
{-(Guard
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Integer)-})-})-}
{-(ConstructorIdentifier)-})-})-})-})-})-})-}
(Function
(VariableIdentifier)
(VariableIdentifier)
(Statements
(Match
(VariableIdentifier)
(Statements
(Pattern
(ConstructorPattern
(Statements
(ConstructorIdentifier)
{+(Wildcard)+}
{-(VariableIdentifier)-}))
{ (CaseGuardPattern
{-(Guard
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Integer)-})-})-}
{-(Guard
{-(ConstructorIdentifier)-})-}
{-(Guard
{-(Let
{-(TypeSignature
{-(VariableIdentifier)-}
{-(FunctionType
{-(Type
{-(TypeConstructorIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-}
{-(Type
{-(TypeConstructorIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Empty)-})-})-}
{-(ConstructorIdentifier)-})
->(Statements
{+(VariableIdentifier)+}
{+(Statements
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(ConstructorIdentifier)+})+})+})+}) })
(Pattern
(ConstructorIdentifier)
(ConstructorIdentifier))))))
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(Match
{+(VariableIdentifier)+}
{+(Statements
{+(Pattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(Statements
{+(VariableIdentifier)+}
{+(Statements
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(Integer)+})+})+})+})+})+}
{+(Pattern
{+(ConstructorIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(Statements
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(Integer)+})+})+})+})+})+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(Match
{+(VariableIdentifier)+}
{+(Statements
{+(Pattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+}
{+(VariableIdentifier)+})+}
{+(Pattern
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+}
{+(Statements
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(Integer)+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(Integer)+})+})+})+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(Lambda
{+(VariableIdentifier)+}
{+(Match
{+(VariableIdentifier)+}
{+(Pattern
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(LambdaCase
{+(Pattern
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(Wildcard)+}
{+(Wildcard)+}
{+(Wildcard)+}
{+(Wildcard)+}
{+(VariableIdentifier)+}
{+(Wildcard)+})+})+})+})+}
{+(Do
{+(BindPattern
{+(VariableIdentifier)+}
{+(InfixOperatorApp
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(App
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableIdentifier)+})+})+})+}
{+(BindPattern
{+(VariableIdentifier)+}
{+(App
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableIdentifier)+})+})+}
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Pattern
{+(Wildcard)+}
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(TextElement)+})+})+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(FunctionGuardPattern
{+(Guard
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Integer)+})+})+}
{+(Guard
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Integer)+})+})+}
{+(ConstructorIdentifier)+})+}
{+(FunctionGuardPattern
{+(Guard
{+(VariableIdentifier)+})+}
{+(ConstructorIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(Do
{+(Let
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Empty)+})+}
{+(BindPattern
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+}
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(Do
{+(Let
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(Empty)+})+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(Integer)+})+})+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(AsPattern
{+(VariableIdentifier)+}
{+(ConstructorIdentifier)+})+}
{+(Statements
{+(LabeledUpdate
{+(VariableIdentifier)+}
{+(FieldBind
{+(VariableIdentifier)+}
{+(Integer)+})+}
{+(FieldBind
{+(VariableIdentifier)+}
{+(Integer)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(AsPattern
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(FieldPattern
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+}
{+(FieldPattern
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Statements
{+(LabeledUpdate
{+(VariableIdentifier)+}
{+(FieldBind
{+(VariableIdentifier)+}
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Integer)+})+})+}
{+(FieldBind
{+(VariableIdentifier)+}
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(TextElement)+})+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(TypeApp
{+(ConstructorIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(VariableIdentifier)+}
{+(TypeApp
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(TextElement)+})+})+})+})+})+}
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{+(Function
{+(VariableIdentifier)+}
{+(Statements
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(VariableIdentifier)+}
{+(TypeApp
{+(ConstructorPattern
{+(Statements
{+(QualifiedConstructorIdentifier
{+(ModuleIdentifier)+}
{+(ConstructorIdentifier)+})+}
{+(TextElement)+})+})+})+})+})+}
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(ConstructorIdentifier)+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(QualifiedConstructorIdentifier
{+(ModuleIdentifier)+}
{+(ConstructorIdentifier)+})+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(ConstructorIdentifier)+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(QualifiedConstructorIdentifier
{+(ModuleIdentifier)+}
{+(ConstructorIdentifier)+})+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(ConstructorIdentifier)+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(QualifiedConstructorIdentifier
{+(ModuleIdentifier)+}
{+(ConstructorIdentifier)+})+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(ConstructorIdentifier)+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(TypeApp
{+(QualifiedConstructorIdentifier
{+(ModuleIdentifier)+}
{+(ConstructorIdentifier)+})+})+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(TypeApp
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(App
{+(ConstructorIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(VariableIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(QualifiedVariableIdentifier
{+(QualifiedModuleIdentifier
{+(ModuleIdentifier)+}
{+(ModuleIdentifier)+})+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(QualifiedVariableIdentifier
{+(ModuleIdentifier)+}
{+(VariableIdentifier)+})+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(ConstructorIdentifier)+}
{+(Empty)+}
{+(PromotedTypeOperator
{+(ConstructorOperator
{+(ConstructorSymbol)+})+})+}
{+(ConstructorIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(ConstructorIdentifier)+}
{+(Empty)+}
{+(PromotedTypeOperator
{+(ConstructorOperator
{+(ConstructorSymbol)+})+})+}
{+(ConstructorIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableOperator
{+(VariableSymbol)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(InfixOperatorApp
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableOperator
{+(VariableSymbol)+})+}
Update test fixtures
2018-06-25 21:20:30 +03:00
{+(Statements)+})+})+})+}
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(Integer)+}
{+(Statements)+})+})+}
(Function
(VariableIdentifier)
{-(VariableIdentifier)-}
(Statements
{+(Integer)+}
{+(Statements)+}
{-(Match
{-(VariableIdentifier)-}
{-(Statements
{-(Pattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(Wildcard)-})-})-}
{-(Statements
{-(VariableIdentifier)-}
{-(Statements
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(ConstructorIdentifier)-})-})-})-})-})-}
{-(Pattern
{-(ConstructorIdentifier)-}
{-(ConstructorIdentifier)-})-})-})-}))
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(Statements
{+(Comment)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(Statements
{+(Comment)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(Statements
{+(Comment)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(Statements
{+(Pragma)+})+})+})+}
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(Match
{-(VariableIdentifier)-}
{-(Statements
{-(Pattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(Statements
{-(VariableIdentifier)-}
{-(Statements
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-})-})-})-})-})-}
{-(Pattern
{-(ConstructorIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(Statements
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-})-})-})-})-})-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(Match
{-(VariableIdentifier)-}
{-(Statements
{-(Pattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-})-}
{-(VariableIdentifier)-})-}
{-(Pattern
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-}
{-(Statements
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-})-})-})-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Lambda
{-(VariableIdentifier)-}
{-(Match
{-(VariableIdentifier)-}
{-(Pattern
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-})-}
(Function
(VariableIdentifier)
(Statements
{+(Integer)+}
{-(InfixOperatorApp
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(LambdaCase
{-(Pattern
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(Wildcard)-}
{-(Wildcard)-}
{-(Wildcard)-}
{-(Wildcard)-}
{-(VariableIdentifier)-}
{-(Wildcard)-})-})-})-})-}
{-(Do
{-(BindPattern
{-(VariableIdentifier)-}
{-(InfixOperatorApp
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(App
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableIdentifier)-})-})-})-}
{-(BindPattern
{-(VariableIdentifier)-}
{-(App
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableIdentifier)-})-})-}
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Pattern
{-(Wildcard)-}
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(TextElement)-})-})-})-})-}))
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(VariableIdentifier)+}
{+(ConstructorOperator
{+(ConstructorSymbol)+})+}
{+(VariableIdentifier)+})+}
{+(ViewPattern
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(TypeSignature
{+(VariableIdentifier)+}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(ContextAlt
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{+(TypeSignature
{+(ImplicitParameterIdentifier)+}
{+(FunctionType
{+(Type
{+(TypeVariableIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+}
{+(FunctionType
{+(Type
{+(TypeVariableIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+}
{+(Type
{+(TypeConstructorIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+})+})+})+})+}
{+(FunctionType
{+(Type
{+(Array
{+(Type
{+(TypeVariableIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+})+}
{+(TypeParameters)+}
{+(Empty)+})+}
{+(Type
{+(Array
{+(Type
{+(TypeVariableIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+})+}
{+(TypeParameters)+}
{+(Empty)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(ImplicitParameterIdentifier)+})+})+})+}
{+(Function
{+(VariableIdentifier)+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(AnnotatedTypeVariable
{+(TypeVariableIdentifier)+}
{+(ConstructorPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(VariableIdentifier)+}
{+(VariableIdentifier)+})+})+})+}
{+(VariableIdentifier)+})+})+}
{+(Statements
{+(VariableIdentifier)+})+})+}
{+(TypeSignature
{+(VariableIdentifier)+}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(ContextAlt
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{+(Statements
{+(Class
{+(TypeClassIdentifier)+}
{+(TypeVariableIdentifier)+})+}
{+(Class
{+(TypeClassIdentifier)+}
{+(Statements
{+(QuotedName
{+(TypeConstructorIdentifier)+})+}
{+(TypeVariableIdentifier)+})+})+}
{+(EqualityConstraint
{+(Class
{+(TypeClassIdentifier)+}
{+(TypeVariableIdentifier)+})+}
{+(Class
{+(QuotedName
{+(TypeConstructorIdentifier)+})+}
{+(TypeVariableIdentifier)+})+})+})+})+}
{+(FunctionType
{+(Type
{+(TypeConstructorIdentifier)+}
{+(TypeParameters)+}
{+(Empty)+})+}
{+(FunctionType
{+(Type
{+(TypeConstructorIdentifier)+}
{+(TypeParameters
{+(TypeVariableIdentifier)+}
{+(TypeVariableIdentifier)+})+}
{+(Empty)+})+}
{+(FunctionType
{+(Type
{+(TypeConstructorIdentifier)+}
{+(TypeParameters
{+(TypeVariableIdentifier)+}
{+(TypeVariableIdentifier)+})+}
{+(Empty)+})+}
{+(Type
{+(TypeConstructorIdentifier)+}
{+(TypeParameters
{+(TypeVariableIdentifier)+}
{+(TypeVariableIdentifier)+})+}
{+(Empty)+})+})+})+})+})+}
Update test fixtures
2018-06-25 21:20:30 +03:00
{+(Function
{+(VariableIdentifier)+}
{+(VariableIdentifier)+}
{+(Statements
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+}
{+(Statements
{+(Function
{+(VariableIdentifier)+}
{+(LabeledPattern
{+(Statements
{+(ConstructorIdentifier)+}
{+(RecordWildCards)+})+})+}
{+(Statements
{+(Let
{+(Function
{+(VariableIdentifier)+}
{+(Statements
{+(App
{+(App
{+(VariableIdentifier)+}
Update test fixtures
2018-06-25 21:20:30 +03:00
{+(Empty)+}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(RightOperatorSection
{+(VariableOperator
{+(VariableSymbol)+})+}
{+(Character)+})+})+}
{+(Empty)+}
{+(App
{+(VariableIdentifier)+}
{+(Empty)+}
{+(VariableIdentifier)+})+})+})+})+}
Update test fixtures
2018-06-25 21:20:30 +03:00
{+(App
{+(App
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(VariableIdentifier)+}
Update test fixtures
2018-06-25 21:20:30 +03:00
{+(Empty)+}
{+(VariableIdentifier)+})+}
{+(Empty)+}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{+(VariableIdentifier)+})+})+})+})+})+})+})+}
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(FunctionGuardPattern
{-(Guard
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Integer)-})-})-}
{-(Guard
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Integer)-})-})-}
{-(ConstructorIdentifier)-})-}
{-(FunctionGuardPattern
{-(Guard
{-(VariableIdentifier)-})-}
{-(ConstructorIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(Do
{-(Let
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Empty)-})-}
{-(BindPattern
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-}
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(Do
{-(Let
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(Empty)-})-}
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-})-})-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(AsPattern
{-(VariableIdentifier)-}
{-(ConstructorIdentifier)-})-}
{-(Statements
{-(LabeledUpdate
{-(VariableIdentifier)-}
{-(FieldBind
{-(VariableIdentifier)-}
{-(Integer)-})-}
{-(FieldBind
{-(VariableIdentifier)-}
{-(Integer)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(AsPattern
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(FieldPattern
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-}
{-(FieldPattern
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Statements
{-(LabeledUpdate
{-(VariableIdentifier)-}
{-(FieldBind
{-(VariableIdentifier)-}
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Integer)-})-})-}
{-(FieldBind
{-(VariableIdentifier)-}
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(TextElement)-})-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(TypeApp
{-(ConstructorIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(VariableIdentifier)-}
{-(TypeApp
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(TextElement)-})-})-})-})-})-}
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{-(Function
{-(VariableIdentifier)-}
{-(Statements
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(VariableIdentifier)-}
{-(TypeApp
{-(ConstructorPattern
{-(Statements
{-(QualifiedConstructorIdentifier
{-(ModuleIdentifier)-}
{-(ConstructorIdentifier)-})-}
{-(TextElement)-})-})-})-})-})-}
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(ConstructorIdentifier)-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(QualifiedConstructorIdentifier
{-(ModuleIdentifier)-}
{-(ConstructorIdentifier)-})-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(ConstructorIdentifier)-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(QualifiedConstructorIdentifier
{-(ModuleIdentifier)-}
{-(ConstructorIdentifier)-})-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(ConstructorIdentifier)-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(QualifiedConstructorIdentifier
{-(ModuleIdentifier)-}
{-(ConstructorIdentifier)-})-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(ConstructorIdentifier)-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(TypeApp
{-(QualifiedConstructorIdentifier
{-(ModuleIdentifier)-}
{-(ConstructorIdentifier)-})-})-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(TypeApp
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(App
{-(ConstructorIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(VariableIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(QualifiedVariableIdentifier
{-(QualifiedModuleIdentifier
{-(ModuleIdentifier)-}
{-(ModuleIdentifier)-})-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(QualifiedVariableIdentifier
{-(ModuleIdentifier)-}
{-(VariableIdentifier)-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(ConstructorIdentifier)-}
{-(Empty)-}
{-(PromotedTypeOperator
{-(ConstructorOperator
{-(ConstructorSymbol)-})-})-}
{-(ConstructorIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(ConstructorIdentifier)-}
{-(Empty)-}
{-(PromotedTypeOperator
{-(ConstructorOperator
{-(ConstructorSymbol)-})-})-}
{-(ConstructorIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableOperator
{-(VariableSymbol)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(InfixOperatorApp
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableOperator
{-(VariableSymbol)-})-}
Update test fixtures
2018-06-25 21:20:30 +03:00
{-(Statements)-})-})-})-}
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-}
{-(Statements)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-}
{-(Statements)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(Statements
{-(Comment)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(Statements
{-(Comment)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(Statements
{-(Comment)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(Statements
{-(Pragma)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(Integer)-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(VariableIdentifier)-}
{-(ConstructorOperator
{-(ConstructorSymbol)-})-}
{-(VariableIdentifier)-})-}
{-(ViewPattern
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(TypeSignature
{-(VariableIdentifier)-}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(ContextAlt
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{-(TypeSignature
{-(ImplicitParameterIdentifier)-}
{-(FunctionType
{-(Type
{-(TypeVariableIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-}
{-(FunctionType
{-(Type
{-(TypeVariableIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-}
{-(Type
{-(TypeConstructorIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-})-})-})-})-}
{-(FunctionType
{-(Type
{-(Array
{-(Type
{-(TypeVariableIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-})-}
{-(TypeParameters)-}
{-(Empty)-})-}
{-(Type
{-(Array
{-(Type
{-(TypeVariableIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-})-}
{-(TypeParameters)-}
{-(Empty)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(ImplicitParameterIdentifier)-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(AnnotatedTypeVariable
{-(TypeVariableIdentifier)-}
{-(ConstructorPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(VariableIdentifier)-}
{-(VariableIdentifier)-})-})-})-}
{-(VariableIdentifier)-})-})-}
{-(Statements
{-(VariableIdentifier)-})-})-}
{-(TypeSignature
{-(VariableIdentifier)-}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(ContextAlt
Add missing assignments I discovered a test file in tree-sitter-haskell I overlooked while assigning semantic.
2018-06-20 03:37:40 +03:00
{-(Statements
{-(Class
{-(TypeClassIdentifier)-}
{-(TypeVariableIdentifier)-})-}
{-(Class
{-(TypeClassIdentifier)-}
{-(Statements
{-(QuotedName
{-(TypeConstructorIdentifier)-})-}
{-(TypeVariableIdentifier)-})-})-}
{-(EqualityConstraint
{-(Class
{-(TypeClassIdentifier)-}
{-(TypeVariableIdentifier)-})-}
{-(Class
{-(QuotedName
{-(TypeConstructorIdentifier)-})-}
{-(TypeVariableIdentifier)-})-})-})-})-}
{-(FunctionType
{-(Type
{-(TypeConstructorIdentifier)-}
{-(TypeParameters)-}
{-(Empty)-})-}
{-(FunctionType
{-(Type
{-(TypeConstructorIdentifier)-}
{-(TypeParameters
{-(TypeVariableIdentifier)-}
{-(TypeVariableIdentifier)-})-}
{-(Empty)-})-}
{-(FunctionType
{-(Type
{-(TypeConstructorIdentifier)-}
{-(TypeParameters
{-(TypeVariableIdentifier)-}
{-(TypeVariableIdentifier)-})-}
{-(Empty)-})-}
{-(Type
{-(TypeConstructorIdentifier)-}
{-(TypeParameters
{-(TypeVariableIdentifier)-}
{-(TypeVariableIdentifier)-})-}
Update test fixtures
2018-06-25 21:20:30 +03:00
{-(Empty)-})-})-})-})-})-}
{-(Function
{-(VariableIdentifier)-}
{-(VariableIdentifier)-}
{-(Statements
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-}
{-(Statements
{-(Function
{-(VariableIdentifier)-}
{-(LabeledPattern
{-(Statements
{-(ConstructorIdentifier)-}
{-(RecordWildCards)-})-})-}
{-(Statements
{-(Let
{-(Function
{-(VariableIdentifier)-}
{-(Statements
{-(App
{-(App
{-(VariableIdentifier)-}
Update test fixtures
2018-06-25 21:20:30 +03:00
{-(Empty)-}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(RightOperatorSection
{-(VariableOperator
{-(VariableSymbol)-})-}
{-(Character)-})-})-}
{-(Empty)-}
{-(App
{-(VariableIdentifier)-}
{-(Empty)-}
{-(VariableIdentifier)-})-})-})-})-}
Update test fixtures
2018-06-25 21:20:30 +03:00
{-(App
{-(App
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(VariableIdentifier)-}
Update test fixtures
2018-06-25 21:20:30 +03:00
{-(Empty)-}
{-(VariableIdentifier)-})-}
{-(Empty)-}
Make error reporter API generic Instead of hard-coding the HTTP API we use for uploading errors to our internal service, let the user provide an arbitrary function (in the IO monad) for uploading them. The default config will create an error reporter that logs errors to the console, just like happened before if you didn't set the `HAYSTACK_URL` environment variable.
2019-04-03 22:12:36 +03:00
{-(VariableIdentifier)-})-})-})-})-})-})-})-}))
Reference in New Issue Copy Permalink