tree-sitter-clean 1.0.0__tar.gz

tree_sitter_clean-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ishaq Muhammad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tree_sitter_clean-1.0.0/MANIFEST.in

@@ -0,0 +1,12 @@
+include LICENSE
+include README.md
+include grammar.js
+include binding.gyp
+include queries/*.scm
+include src/grammar.json
+include src/node-types.json
+include src/parser.c
+include src/scanner.c
+include src/tree_sitter/*.h
+include bindings/python/tree_sitter_clean/*.py
+include bindings/python/tree_sitter_clean/*.c

tree_sitter_clean-1.0.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: tree-sitter-clean
+Version: 1.0.0
+Summary: Clean grammar for tree-sitter
+Home-page: https://github.com/ishaq2321/tree-sitter-clean
+Author: Ishaq Muhammad
+Author-email: Ishaq Muhammad <ishaq2321@users.noreply.github.com>
+License: MIT
+Project-URL: repository, https://github.com/ishaq2321/tree-sitter-clean
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# tree-sitter-clean
+
+[![CI][ci]](https://github.com/ishaq2321/tree-sitter-clean/actions/workflows/ci.yml)
+[![discord][discord]](https://discord.gg/w7nTvsVJhm)
+[![matrix][matrix]](https://matrix.to/#/#tree-sitter-chat:matrix.org)
+[![crates][crates]](https://crates.io/crates/tree-sitter-clean)
+[![npm][npm]](https://www.npmjs.com/package/tree-sitter-clean)
+[![pypi][pypi]](https://pypi.org/project/tree-sitter-clean)
+
+Clean grammar for [tree-sitter][].
+
+[tree-sitter]: https://github.com/tree-sitter/tree-sitter
+
+## Description
+
+[Clean](https://clean-lang.org/) is a general-purpose, purely functional programming language with uniqueness typing. This grammar supports:
+
+- Module system (`module`, `import`, `from...import`)
+- Type system (`::`, algebraic data types, records, type classes)
+- Functions (named, guards, `where`/`with` clauses)
+- Patterns (variables, constructors, wildcards, lists, tuples)
+- Expressions (application, infix operators, let, case, lambda)
+- Comprehensions (list comprehensions with generators, guards, let qualifiers)
+- Records (construction, update, field access)
+
+### Node Types
+
+The grammar produces **69 named node types** for precise AST analysis, including:
+- `application` — function/constructor call detection
+- `field_access` — record field access
+- `list_comprehension` — with `generator`, `guard`, `let_qualifier`
+- `record_expression` / `record_update` — record manipulation
+- `wildcard` — `_` pattern
+
+## Usage
+
+### Rust
+```rust
+let mut parser = tree_sitter::Parser::new();
+parser.set_language(&tree_sitter_clean::LANGUAGE.into())?;
+```
+
+### JavaScript
+```js
+const Parser = require("tree-sitter");
+const Clean = require("tree-sitter-clean");
+const parser = new Parser();
+parser.setLanguage(Clean);
+```
+
+### Python
+```python
+import tree_sitter_clean
+```
+
+## References
+
+- [Clean Language Report](https://clean-lang.org/)
+- [Clean Book](https://clean.cs.ru.nl/Clean)
+
+[ci]: https://img.shields.io/github/actions/workflow/status/ishaq2321/tree-sitter-clean/ci.yml?logo=github&label=CI
+[discord]: https://img.shields.io/discord/1063097320771698699?logo=discord&label=discord
+[matrix]: https://img.shields.io/matrix/tree-sitter-chat%3Amatrix.org?logo=matrix&label=matrix
+[npm]: https://img.shields.io/npm/v/tree-sitter-clean?logo=npm
+[crates]: https://img.shields.io/crates/v/tree-sitter-clean?logo=rust
+[pypi]: https://img.shields.io/pypi/v/tree-sitter-clean?logo=pypi&logoColor=ffd242

tree_sitter_clean-1.0.0/README.md

@@ -0,0 +1,66 @@
+# tree-sitter-clean
+
+[![CI][ci]](https://github.com/ishaq2321/tree-sitter-clean/actions/workflows/ci.yml)
+[![discord][discord]](https://discord.gg/w7nTvsVJhm)
+[![matrix][matrix]](https://matrix.to/#/#tree-sitter-chat:matrix.org)
+[![crates][crates]](https://crates.io/crates/tree-sitter-clean)
+[![npm][npm]](https://www.npmjs.com/package/tree-sitter-clean)
+[![pypi][pypi]](https://pypi.org/project/tree-sitter-clean)
+
+Clean grammar for [tree-sitter][].
+
+[tree-sitter]: https://github.com/tree-sitter/tree-sitter
+
+## Description
+
+[Clean](https://clean-lang.org/) is a general-purpose, purely functional programming language with uniqueness typing. This grammar supports:
+
+- Module system (`module`, `import`, `from...import`)
+- Type system (`::`, algebraic data types, records, type classes)
+- Functions (named, guards, `where`/`with` clauses)
+- Patterns (variables, constructors, wildcards, lists, tuples)
+- Expressions (application, infix operators, let, case, lambda)
+- Comprehensions (list comprehensions with generators, guards, let qualifiers)
+- Records (construction, update, field access)
+
+### Node Types
+
+The grammar produces **69 named node types** for precise AST analysis, including:
+- `application` — function/constructor call detection
+- `field_access` — record field access
+- `list_comprehension` — with `generator`, `guard`, `let_qualifier`
+- `record_expression` / `record_update` — record manipulation
+- `wildcard` — `_` pattern
+
+## Usage
+
+### Rust
+```rust
+let mut parser = tree_sitter::Parser::new();
+parser.set_language(&tree_sitter_clean::LANGUAGE.into())?;
+```
+
+### JavaScript
+```js
+const Parser = require("tree-sitter");
+const Clean = require("tree-sitter-clean");
+const parser = new Parser();
+parser.setLanguage(Clean);
+```
+
+### Python
+```python
+import tree_sitter_clean
+```
+
+## References
+
+- [Clean Language Report](https://clean-lang.org/)
+- [Clean Book](https://clean.cs.ru.nl/Clean)
+
+[ci]: https://img.shields.io/github/actions/workflow/status/ishaq2321/tree-sitter-clean/ci.yml?logo=github&label=CI
+[discord]: https://img.shields.io/discord/1063097320771698699?logo=discord&label=discord
+[matrix]: https://img.shields.io/matrix/tree-sitter-chat%3Amatrix.org?logo=matrix&label=matrix
+[npm]: https://img.shields.io/npm/v/tree-sitter-clean?logo=npm
+[crates]: https://img.shields.io/crates/v/tree-sitter-clean?logo=rust
+[pypi]: https://img.shields.io/pypi/v/tree-sitter-clean?logo=pypi&logoColor=ffd242

tree_sitter_clean-1.0.0/binding.gyp

@@ -0,0 +1,35 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_clean_binding",
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
+      ],
+      "include_dirs": [
+        "src",
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+      ],
+      "variables": {
+        "has_scanner": "<!(node -p \"fs.existsSync('src/scanner.c')\")"
+      },
+      "conditions": [
+        ["has_scanner=='true'", {
+          "sources+": ["src/scanner.c"],
+        }],
+        ["OS!='win'", {
+          "cflags_c": [
+            "-std=c11",
+          ],
+        }, {
+          "cflags_c": [
+            "/std:c11",
+            "/utf-8",
+          ],
+        }],
+      ],
+    }
+  ]
+}

tree_sitter_clean-1.0.0/bindings/python/tree_sitter_clean/__init__.py

@@ -0,0 +1,26 @@
+"""Clean grammar for tree-sitter"""
+
+from importlib.resources import files as _files
+
+from ._binding import language
+
+
+def _get_query(name, file):
+    query = _files(f"{__package__}.queries") / file
+    globals()[name] = query.read_text()
+    return globals()[name]
+
+
+def __getattr__(name):
+    if name == "HIGHLIGHTS_QUERY":
+        return _get_query("HIGHLIGHTS_QUERY", "highlights.scm")
+    if name == "TAGS_QUERY":
+        return _get_query("TAGS_QUERY", "tags.scm")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "language",
+    "HIGHLIGHTS_QUERY",
+    "TAGS_QUERY",
+]

tree_sitter_clean-1.0.0/bindings/python/tree_sitter_clean/binding.c

@@ -0,0 +1,35 @@
+#include <Python.h>
+
+typedef struct TSLanguage TSLanguage;
+
+TSLanguage *tree_sitter_clean(void);
+
+static PyObject* _binding_language(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(args)) {
+    return PyCapsule_New(tree_sitter_clean(), "tree_sitter.Language", NULL);
+}
+
+static struct PyModuleDef_Slot slots[] = {
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+    {0, NULL}
+};
+
+static PyMethodDef methods[] = {
+    {"language", _binding_language, METH_NOARGS,
+     "Get the tree-sitter language for this grammar."},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef module = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "_binding",
+    .m_doc = NULL,
+    .m_size = 0,
+    .m_methods = methods,
+    .m_slots = slots,
+};
+
+PyMODINIT_FUNC PyInit__binding(void) {
+    return PyModuleDef_Init(&module);
+}

tree_sitter_clean-1.0.0/bindings/python/tree_sitter_clean.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: tree-sitter-clean
+Version: 1.0.0
+Summary: Clean grammar for tree-sitter
+Home-page: https://github.com/ishaq2321/tree-sitter-clean
+Author: Ishaq Muhammad
+Author-email: Ishaq Muhammad <ishaq2321@users.noreply.github.com>
+License: MIT
+Project-URL: repository, https://github.com/ishaq2321/tree-sitter-clean
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# tree-sitter-clean
+
+[![CI][ci]](https://github.com/ishaq2321/tree-sitter-clean/actions/workflows/ci.yml)
+[![discord][discord]](https://discord.gg/w7nTvsVJhm)
+[![matrix][matrix]](https://matrix.to/#/#tree-sitter-chat:matrix.org)
+[![crates][crates]](https://crates.io/crates/tree-sitter-clean)
+[![npm][npm]](https://www.npmjs.com/package/tree-sitter-clean)
+[![pypi][pypi]](https://pypi.org/project/tree-sitter-clean)
+
+Clean grammar for [tree-sitter][].
+
+[tree-sitter]: https://github.com/tree-sitter/tree-sitter
+
+## Description
+
+[Clean](https://clean-lang.org/) is a general-purpose, purely functional programming language with uniqueness typing. This grammar supports:
+
+- Module system (`module`, `import`, `from...import`)
+- Type system (`::`, algebraic data types, records, type classes)
+- Functions (named, guards, `where`/`with` clauses)
+- Patterns (variables, constructors, wildcards, lists, tuples)
+- Expressions (application, infix operators, let, case, lambda)
+- Comprehensions (list comprehensions with generators, guards, let qualifiers)
+- Records (construction, update, field access)
+
+### Node Types
+
+The grammar produces **69 named node types** for precise AST analysis, including:
+- `application` — function/constructor call detection
+- `field_access` — record field access
+- `list_comprehension` — with `generator`, `guard`, `let_qualifier`
+- `record_expression` / `record_update` — record manipulation
+- `wildcard` — `_` pattern
+
+## Usage
+
+### Rust
+```rust
+let mut parser = tree_sitter::Parser::new();
+parser.set_language(&tree_sitter_clean::LANGUAGE.into())?;
+```
+
+### JavaScript
+```js
+const Parser = require("tree-sitter");
+const Clean = require("tree-sitter-clean");
+const parser = new Parser();
+parser.setLanguage(Clean);
+```
+
+### Python
+```python
+import tree_sitter_clean
+```
+
+## References
+
+- [Clean Language Report](https://clean-lang.org/)
+- [Clean Book](https://clean.cs.ru.nl/Clean)
+
+[ci]: https://img.shields.io/github/actions/workflow/status/ishaq2321/tree-sitter-clean/ci.yml?logo=github&label=CI
+[discord]: https://img.shields.io/discord/1063097320771698699?logo=discord&label=discord
+[matrix]: https://img.shields.io/matrix/tree-sitter-chat%3Amatrix.org?logo=matrix&label=matrix
+[npm]: https://img.shields.io/npm/v/tree-sitter-clean?logo=npm
+[crates]: https://img.shields.io/crates/v/tree-sitter-clean?logo=rust
+[pypi]: https://img.shields.io/pypi/v/tree-sitter-clean?logo=pypi&logoColor=ffd242

tree_sitter_clean-1.0.0/bindings/python/tree_sitter_clean.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+MANIFEST.in
+README.md
+binding.gyp
+grammar.js
+pyproject.toml
+setup.py
+bindings/python/tree_sitter_clean/__init__.py
+bindings/python/tree_sitter_clean/binding.c
+bindings/python/tree_sitter_clean.egg-info/PKG-INFO
+bindings/python/tree_sitter_clean.egg-info/SOURCES.txt
+bindings/python/tree_sitter_clean.egg-info/dependency_links.txt
+bindings/python/tree_sitter_clean.egg-info/not-zip-safe
+bindings/python/tree_sitter_clean.egg-info/top_level.txt
+queries/highlights.scm
+queries/tags.scm
+src/grammar.json
+src/node-types.json
+src/parser.c
+src/scanner.c
+src/tree_sitter/alloc.h
+src/tree_sitter/array.h
+src/tree_sitter/parser.h

tree_sitter_clean-1.0.0/bindings/python/tree_sitter_clean.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tree_sitter_clean-1.0.0/bindings/python/tree_sitter_clean.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

tree_sitter_clean-1.0.0/bindings/python/tree_sitter_clean.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+_binding
+tree_sitter_clean

tree_sitter_clean-1.0.0/grammar.js

@@ -0,0 +1,269 @@
+module.exports = grammar({
+  name: "clean",
+
+  extras: ($) => [/\s/, $.line_comment, $.block_comment],
+
+  word: ($) => $.identifier,
+
+  conflicts: ($) => [
+    [$._expression],
+    [$._expression, $._pattern],
+    [$.class_declaration],
+    [$.instance_declaration],
+    [$.data_constructor, $._type_atom],
+    [$._expression, $.let_expression],
+    [$._expression, $.let_before_expression],
+  ],
+
+  externals: ($) => [$._layout_semicolon, $._layout_start, $._layout_end],
+
+  rules: {
+    source_file: ($) =>
+      seq(
+        optional($._layout_start),
+        repeat(seq($._declaration, optional($._layout_semicolon))),
+        optional($._layout_end),
+      ),
+
+    _declaration: ($) =>
+      choice(
+        $.module_declaration,
+        $.import_declaration,
+        $.type_signature,
+        $.type_definition,
+        $.function_declaration,
+        $.class_declaration,
+        $.instance_declaration,
+      ),
+
+    module_declaration: ($) => seq(optional(choice("implementation", "definition", "system")), "module", $.identifier),
+
+    import_declaration: ($) =>
+      prec.left(
+        choice(
+          seq("import", $.identifier, repeat(seq(optional(","), $.identifier))),
+          seq("from", $.identifier, "import", $.identifier, repeat(seq(optional(","), $.identifier))),
+        ),
+      ),
+
+    // Type signature: name :: type
+    // e.g. factorial :: Int -> Int
+    // e.g. compose :: (a -> b) (b -> c) -> a -> c
+    type_signature: ($) => seq(field("name", $.identifier), "::", $._type_expression),
+
+    type_definition: ($) =>
+      prec.left(
+        seq(
+          "::",
+          optional(choice("*", "!")),
+          field("name", $.identifier),
+          repeat($.identifier),
+          optional(seq(choice("=", ":=="), $._type_rhs)),
+        ),
+      ),
+
+    _type_rhs: ($) => prec.left(choice($.data_constructors, $.record_definition, $._type_expression)),
+
+    data_constructors: ($) => prec.left(seq($.data_constructor, repeat(seq("|", $.data_constructor)))),
+
+    data_constructor: ($) => prec.left(seq($.identifier, repeat($._type_atom))),
+
+    record_definition: ($) => seq("{", repeat(seq($.record_field, optional(","))), "}"),
+
+    record_field: ($) => seq($.identifier, "::", $._type_expression),
+
+    class_declaration: ($) =>
+      seq(
+        "class",
+        field("name", $.identifier),
+        repeat1($.identifier),
+        optional(seq("where", repeat($.type_signature))),
+      ),
+
+    instance_declaration: ($) =>
+      seq(
+        "instance",
+        field("name", $.identifier),
+        repeat1($._type_atom),
+        optional(seq("where", repeat($.function_declaration))),
+      ),
+
+    function_declaration: ($) =>
+      seq(
+        field("name", $.identifier),
+        repeat($._pattern),
+        choice(seq("=", $._expression), repeat1($.guard_equation)),
+        optional(choice($.where_block, $.with_block)),
+      ),
+
+    guard_equation: ($) => seq("|", $._expression, "=", $._expression),
+
+    // where block: local definitions after a function body
+    // e.g. f x = g x where g y = y + 1
+    where_block: ($) => seq("where", $._layout_start, repeat1(seq(choice($.type_signature, $.function_declaration), optional($._layout_semicolon))), $._layout_end),
+
+    // with block: similar to where but with different semantics in Clean
+    with_block: ($) => seq("with", $._layout_start, repeat1(seq(choice($.type_signature, $.function_declaration), optional($._layout_semicolon))), $._layout_end),
+
+    _pattern: ($) =>
+      choice(
+        $.wildcard,
+        $.identifier,
+        $.lazy_pattern,
+        seq("(", repeat1(choice($._pattern, ",", $.operator)), ")"),
+        seq("[", repeat(seq($._pattern, optional(","))), "]"),
+      ),
+
+    // `_` wildcard — matches anything, binds nothing
+    wildcard: ($) => "_",
+
+    // Lazy pattern: ~pattern — defers evaluation until the value is needed
+    lazy_pattern: ($) => seq("~", $._pattern),
+
+    // ---- Type expressions ----
+    // Clean type expressions: right-associative -> for functions,
+    // left-associative juxtaposition for type application.
+    //
+    // Examples:
+    //   Int                     → _type_atom
+    //   a -> b                  → type_fun(a, ->, b)
+    //   a -> b -> c             → type_fun(a, ->, type_fun(b, ->, c))
+    //   Maybe a                 → type_application(Maybe, a)
+    //   Maybe a -> b            → type_fun(type_application(Maybe, a), ->, b)
+    //   (a, b) -> c             → type_fun((a, b), ->, c)
+    //   [Int]                   → _type_atom([Int])
+    //   *World                  → _type_atom(*World)
+
+    _type_expression: ($) =>
+      choice(
+        $.type_fun,
+        $._type_application,
+      ),
+
+    type_fun: ($) => prec.right(1, seq($._type_expression, "->", $._type_expression)),
+
+    _type_application: ($) =>
+      prec.left(2, seq($._type_atom, repeat($._type_atom))),
+
+    _type_atom: ($) =>
+      choice(
+        $.identifier,
+        "*",
+        "!",
+        seq("(", $._type_expression, repeat(seq(",", $._type_expression)), ")"),
+        seq("[", $._type_expression, "]"),
+      ),
+
+    // ---- Term expressions ----
+
+    _expression: ($) =>
+      prec.left(
+        choice(
+          seq($._expression, $.operator, $._expression),
+          $.application,
+          $.lambda_expression,
+          $.field_access,
+          $.list_comprehension,
+          $.record_expression,
+          $.record_update,
+          $.let_expression,
+          $.let_before_expression,
+          $.case_expression,
+          $.identifier,
+          $.number,
+          $.string,
+          seq("(", repeat(choice($._expression, $.operator, ",")), ")"),
+          seq("[", repeat(seq($._expression, optional(","))), "]"),
+        ),
+      ),
+
+    application: ($) => prec.left(10, seq($._expression, $._expression)),
+
+    // Lambda: \pattern1 pattern2 ... -> expr  or  \pattern = expr
+    lambda_expression: ($) =>
+      prec.left(seq("\\", repeat1($._pattern), choice("->", "="), $._expression)),
+
+    // Record field access: `record.field` or `record!field` (strict)
+    field_access: ($) => prec.left(13, seq($._expression, choice(".", "!"), $.identifier)),
+
+    // Record construction: `{ name = "Ishaq", age = 25 }`
+    record_expression: ($) =>
+      seq(
+        "{",
+        repeat(seq(
+          field("name", $.identifier),
+          "=",
+          field("value", $._expression),
+          optional(","),
+        )),
+        "}",
+      ),
+
+    // Record update: `{ person & age = 26 }`
+    record_update: ($) =>
+      seq(
+        "{",
+        field("record", $._expression),
+        "&",
+        repeat(seq(
+          optional(","),
+          field("name", $.identifier),
+          "=",
+          field("value", $._expression),
+        )),
+        "}",
+      ),
+
+    // List comprehension: `[x * 2 \\ x <- [1..10] | isEven x]`
+    list_comprehension: ($) =>
+      seq(
+        "[",
+        field("body", $._expression),
+        "\\\\",
+        repeat1(seq($.comprehension_qualifier, optional(","))),
+        "]",
+      ),
+
+    comprehension_qualifier: ($) =>
+      choice(
+        $.generator,
+        $.guard,
+        $.let_qualifier,
+      ),
+
+    generator: ($) =>
+      seq(
+        field("pattern", $._pattern),
+        "<-",
+        field("expression", $._expression),
+      ),
+
+    guard: ($) => field("condition", $._expression),
+
+    let_qualifier: ($) =>
+      seq(
+        "let",
+        field("name", $.identifier),
+        "=",
+        field("value", $._expression),
+      ),
+
+    let_expression: ($) => seq("let", repeat1(choice($.function_declaration, $.type_signature)), "in", $._expression),
+
+    let_before_expression: ($) =>
+      seq(choice("#", "#!"), $._pattern, "=", $._expression, optional($.let_before_expression)),
+
+    case_expression: ($) => seq("case", $._expression, "of", $._layout_start, repeat1(seq($.case_alternative, optional($._layout_semicolon))), $._layout_end),
+
+    case_alternative: ($) =>
+      seq($._pattern, optional(seq("|", $._expression)), choice("->", "="), $._expression),
+
+    identifier: ($) => /[a-zA-Z_][a-zA-Z0-9_]*/,
+    operator: ($) => /[!@$%^&*+\-=\\|<>\/?~.]+/,
+    number: ($) => /\d+(\.\d+)?/,
+    string: ($) => /"([^"\\]|\\.)*"/,
+
+    line_comment: ($) => token(seq("//", /.*/)),
+    block_comment: ($) => token(seq("/*", /[^*]*\*+([^/*][^*]*\*+)*/, "/")),
+  },
+})