github/semantic
1
1
Fork 0
mirror of https://github.com/github/semantic.git synced 2024-12-19 04:41:47 +03:00
Code Issues Projects Releases Wiki Activity
2a788703ba
semantic/test/fixtures/haskell/corpus/literals.parseB.txt

266 lines
5.4 KiB
Plaintext
Raw Normal View History

Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Module
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(ModuleIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Integer)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Integer)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Integer)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Integer)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Integer)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Integer)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Float)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(ConstructorIdentifier)))
Add literal test fixtures
2018-05-24 01:55:26 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(ConstructorIdentifier)))
Assign character literals
2018-05-25 00:58:54 +03:00
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign character literals
2018-05-25 00:58:54 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign string and array literals
2018-05-25 01:34:18 +03:00
(Character)))
(Function
Be explicit about each identifier type I went through a lot of trouble to make every identifier parsed in `tree-sitter-haskell` as accurate as possible (i.e. type variable identifier vs constructor identifier vs type class identifier). This enables us to keep those distinctions with assignment at the cost of adding more constructors.
2018-06-08 22:05:17 +03:00
(VariableIdentifier)
Add aglebraic datatype tests
2018-06-01 20:56:12 +03:00
(Statements
Assign string and array literals
2018-05-25 01:34:18 +03:00
(Array
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement)
(TextElement))))))
Reference in New Issue Copy Permalink