tree-sitter-tony/tony/corpus/terms.txt

Tony grammar for tree-sitter

==================
abstraction
==================

(a) =>
  a
(a, b) => a
(a :: Type, b :: Type, 1, { c :: Type = 1 }) => a

fib :=
  (0) =>
    0
  (1) => 1
  <a>(n :: a = 2) =>
    fib(n - 1) + fib(n - 2)

<a <: Type>(...a :: a) =>
  b := (c :: Type) =>
    c
  b(1)

() => 1
/ := (a, b) => /

---

(program
  term: (abstraction
    branch: (abstraction_branch
      element: (identifier_pattern
        name: (identifier_pattern_name))
      body: (block
        term: (identifier))))
  term: (abstraction
    branch: (abstraction_branch
      element: (identifier_pattern
        name: (identifier_pattern_name))
      element: (identifier_pattern
        name: (identifier_pattern_name))
      body: (block
        term: (identifier))))
  term: (abstraction
    branch: (abstraction_branch
      element: (identifier_pattern
        name: (identifier_pattern_name)
        type: (parametric_type
          name: (type)))
      element: (identifier_pattern
        name: (identifier_pattern_name)
        type: (parametric_type
          name: (type)))
      element: (number)
      element: (destructuring_pattern
        pattern: (struct_pattern
          member: (shorthand_member_pattern
            name: (identifier_pattern_name)
            type: (parametric_type
              name: (type))
            default: (number))))
      body: (block
        term: (identifier))))
  term: (assignment
    pattern: (identifier_pattern
      name: (identifier_pattern_name))
    value: (abstraction
      branch: (abstraction_branch
        element: (number)
        body: (block
          term: (number)))
      branch: (abstraction_branch
        element: (number)
        body: (block
          term: (number)))
      branch: (abstraction_branch
        typeParameter: (type_variable_declaration
          name: (type_variable_declaration_name))
        element: (identifier_pattern
          name: (identifier_pattern_name)
          type: (type_variable)
          default: (number))
        body: (block
          term: (infix_application
            left: (application
              name: (identifier)
              element: (argument
                value: (infix_application
                  left: (identifier)
                  name: (identifier)
                  right: (number))))
            name: (identifier)
            right: (application
              name: (identifier)
              element: (argument
                value: (infix_application
                  left: (identifier)
                  name: (identifier)
                  right: (number)))))))))
  term: (abstraction
    branch: (abstraction_branch
      typeParameter: (type_variable_declaration
        name: (type_variable_declaration_name)
        constraint: (parametric_type
          name: (type)))
      rest: (identifier_pattern
        name: (identifier_pattern_name)
        type: (type_variable))
      body: (block
        term: (assignment
          pattern: (identifier_pattern
            name: (identifier_pattern_name))
          value: (abstraction
            branch: (abstraction_branch
              element: (identifier_pattern
                name: (identifier_pattern_name)
                type: (parametric_type
                  name: (type)))
              body: (block
                term: (identifier)))))
        term: (application
          name: (identifier)
          element: (argument
            value: (number))))))
  term: (abstraction
    branch: (abstraction_branch
    body: (block
      term: (number))))
  term: (assignment
    pattern: (identifier_pattern
      name: (identifier_pattern_name))
    value: (abstraction
      branch: (abstraction_branch
        element: (identifier_pattern
          name: (identifier_pattern_name))
        element: (identifier_pattern
          name: (identifier_pattern_name))
        body: (block
          term: (identifier))))))

==================
application
==================

a(1)(1, 2)
+(1)
a<Type<Type, Type>, Type>(?, 1)
+ 1
1 `a` -b()
a(...(a, b))

---

(program
  term: (application
    name: (application
      name: (identifier)
      element: (argument
        value: (number)))
    element: (argument
      value: (number))
    element: (argument
      value: (number)))
  term: (prefix_application
    name: (identifier)
    value: (group
      term: (number)))
  term: (application
    name: (identifier)
    typeArgument: (parametric_type
      name: (type)
      argument: (parametric_type
        name: (type))
      argument: (parametric_type
        name: (type)))
    typeArgument: (parametric_type
      name: (type))
    element: (argument)
    element: (argument
      value: (number)))
  term: (prefix_application
    name: (identifier)
    value: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (prefix_application
      name: (identifier)
      value: (application
        name: (identifier))))
  term: (application
    name: (identifier)
    element: (argument
      value: (spread
        value: (tuple
          element: (identifier)
          element: (identifier))))))

==================
prefix application
==================

!false
+1
-1
~1

---

(program
  term: (prefix_application
    name: (identifier)
    value: (boolean))
  term: (prefix_application
    name: (identifier)
    value: (number))
  term: (prefix_application
    name: (identifier)
    value: (number))
  term: (prefix_application
    name: (identifier)
    value: (number)))

==================
infix application
==================

1 .. 1
1 ^ 1
1 * 1
1 / 1
1 + 1
1 - 1
1 % 1
1 < 1
1 <= 1
1 > 1
1 >= 1
1 == 1
1 != 1
a === 1
1 !== b
a ~ b
false && false
false || false
false ==> true <=> true
false && false || false
false || false && false
1 + 1 % 1
1 - 1 + 1
1 - -1
1 * 1 / 1 - 1
false || !false
(a.b) . c ^ 1 . (d.e)

---

(program
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (identifier)
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (identifier))
  term: (infix_application
    left: (identifier)
    name: (identifier)
    right: (identifier))
  term: (infix_application
    left: (boolean)
    name: (identifier)
    right: (boolean))
  term: (infix_application
    left: (boolean)
    name: (identifier)
    right: (boolean))
  term: (infix_application
    left: (infix_application
      left: (boolean)
      name: (identifier)
      right: (boolean))
    name: (identifier)
    right: (boolean))
  term: (infix_application
    left: (infix_application
      left: (boolean)
      name: (identifier)
      right: (boolean))
    name: (identifier)
    right: (boolean))
  term: (infix_application
    left: (boolean)
    name: (identifier)
    right: (infix_application
      left: (boolean)
      name: (identifier)
      right: (boolean)))
  term: (infix_application
    left: (infix_application
      left: (number)
      name: (identifier)
      right: (number))
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (infix_application
      left: (number)
      name: (identifier)
      right: (number))
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (number)
    name: (identifier)
    right: (prefix_application
      name: (identifier)
      value: (number)))
  term: (infix_application
    left: (infix_application
      left: (infix_application
        left: (number)
        name: (identifier)
        right: (number))
      name: (identifier)
      right: (number))
    name: (identifier)
    right: (number))
  term: (infix_application
    left: (boolean)
    name: (identifier)
    right: (prefix_application
      name: (identifier)
      value: (boolean)))
  term: (infix_application
    left: (pipeline
      value: (group
        term: (pipeline
          value: (identifier)
          name: (identifier)))
      name: (identifier))
    name: (identifier)
    right: (pipeline
      value: (number)
      name: (group
        term: (pipeline
          value: (identifier)
          name: (identifier))))))

==================
pipeline
==================

a.b.c(1)

---

(program
  term: (application
    name: (pipeline
      value: (pipeline
        value: (identifier)
        name: (identifier))
      name: (identifier))
    element: (argument
      value: (number))))

==================
sections
==================

((+) 1)
(1 (+))
(`mod` 1)
(1 `mod`)

---

(program
  term: (right_section
    name: (identifier)
    value: (number))
  term: (left_section
    value: (number)
    name: (identifier))
  term: (right_section
    name: (identifier)
    value: (number))
  term: (left_section
    value: (number)
    name: (identifier)))

==================
access
==================

a[0]
a->b(1)
a.b[c]

---

(program
  term: (access
      name: (identifier)
      value: (number))
  term: (application
    name: (access
      name: (identifier)
      value: (shorthand_access_identifier))
    element: (argument
      value: (number)))
  term: (pipeline
    value: (identifier)
    name: (access
      name: (identifier)
      value: (identifier))))

==================
assignment
==================

a :: Type := 1
a := (a :: Type) =>
  1

---

(program
  term: (assignment
    pattern: (identifier_pattern
      name: (identifier_pattern_name)
      type: (parametric_type
        name: (type)))
    value: (number))
  term: (assignment
    pattern: (identifier_pattern
      name: (identifier_pattern_name))
    value: (abstraction
      branch: (abstraction_branch
        element: (identifier_pattern
          name: (identifier_pattern_name)
          type: (parametric_type
            name: (type)))
        body: (block
          term: (number))))))

==================
export
==================

export a := 1
export a := (x :: a) =>
  1

---

(program
  term: (export
    declaration: (assignment
      pattern: (identifier_pattern
        name: (identifier_pattern_name))
      value: (number)))
  term: (export
    declaration: (assignment
      pattern: (identifier_pattern
        name: (identifier_pattern_name))
      value: (abstraction
        branch: (abstraction_branch
          element: (identifier_pattern
            name: (identifier_pattern_name)
            type: (type_variable))
          body: (block
            term: (number)))))))

==================
return
==================

return 1
return (a :: Type) =>
  1

---

(program
  term: (return
    value: (number))
  term: (return
    value: (abstraction
      branch: (abstraction_branch
        element: (identifier_pattern
          name: (identifier_pattern_name)
          type: (parametric_type
            name: (type)))
        body: (block
          term: (number))))))

==================
if
==================

if false then
  1
if true then
  1
else
  1
a :=
  if true then
    1
  else if false then 1
  else if true then
    1

fn(if false then 1)
if true then 1 else 1

---

(program
  term: (if
    condition: (boolean)
    body: (block
      term: (number)))
  term: (if
    condition: (boolean)
    body: (block
      term: (number))
    else: (block
      term: (number)))
  term: (assignment
    pattern: (identifier_pattern
      name: (identifier_pattern_name))
    value: (if
      condition: (boolean)
      body: (block
        term: (number))
      elseIf: (else_if
        condition: (boolean)
        body: (block
          term: (number)))
      elseIf: (else_if
        condition: (boolean)
        body: (block
          term: (number)))))
  term: (application
    name: (identifier)
    element: (argument
      value: (if
        condition: (boolean)
        body: (block
          term: (number)))))
  term: (if
    condition: (boolean)
    body: (block
      term: (number))
    else: (block
      term: (number))))

==================
case
==================

a :=
  case a
    when 1 then
      1
    else 1

case a
when [1, a :: Type] then
  a
when 1, 1 then 1
else 1

---

(program
  term: (assignment
    pattern: (identifier_pattern
      name: (identifier_pattern_name))
    value: (case
      value: (identifier)
      when: (when
        pattern: (number)
        body: (block
          term: (number)))
      else: (block
        term: (number))))
  term: (case
    value: (identifier)
    when: (when
      pattern: (destructuring_pattern
        pattern: (list_pattern
          element: (number)
          element: (identifier_pattern
            name: (identifier_pattern_name)
            type: (parametric_type
              name: (type)))))
      body: (block
        term: (identifier)))
    when: (when
      pattern: (number)
      pattern: (number)
      body: (block
        term: (number)))
    else: (block
      term: (number))))

==================
enum
==================

enum Type
  a
  b = 'string'

---

(program
  term: (enum
    name: (type)
    value: (enum_value
      name: (identifier_pattern_name))
    value: (enum_value
      name: (identifier_pattern_name)
      value: (string))))

==================
class
==================

class Type<a>
  a :: a -> Number
  b :: a -> Number
class Ord<a <: Eq, b <: (Num; Eq; Ord)>
  compare :: a -> b -> Number

---

(program
  term: (class
    name: (type_declaration
      name: (type)
      parameter: (type_variable_declaration
        name: (type_variable_declaration_name)))
    member: (class_member
      name: (identifier_pattern_name)
      type: (curried_type
        from: (type_variable)
        to: (parametric_type
          name: (type))))
    member: (class_member
      name: (identifier_pattern_name)
      type: (curried_type
        from: (type_variable)
        to: (parametric_type
          name: (type)))))
  term: (class
    name: (type_declaration
      name: (type)
      parameter: (type_variable_declaration
        name: (type_variable_declaration_name)
        constraint: (parametric_type
          name: (type)))
      parameter: (type_variable_declaration
        name: (type_variable_declaration_name)
        constraint: (parametric_type
          name: (type))
        constraint: (parametric_type
          name: (type))
        constraint: (parametric_type
          name: (type))))
    member: (class_member
      name: (identifier_pattern_name)
      type: (curried_type
        from: (type_variable)
        to: (curried_type
          from: (type_variable)
          to: (parametric_type
            name: (type)))))))

==================
instance
==================

instance Ord<Number>
  compare := 1

---

(program
  term: (instance
    name: (parametric_type
      name: (type)
      argument: (parametric_type
        name: (type)))
    assignment: (assignment
      pattern: (identifier_pattern
        name: (identifier_pattern_name))
      value: (number))))

==================
struct
==================

{}
{ a, b }
{ ['a']: 1, ...b, c: 'str', d, e }

---

(program
  term: (struct)
  term: (struct
    member: (shorthand_member)
    member: (shorthand_member))
  term: (struct
    member: (member
      key: (string)
      value: (number))
    member: (spread
      value: (identifier))
    member: (member
      key: (shorthand_member_identifier)
      value: (string))
    member: (shorthand_member)
    member: (shorthand_member)))

==================
tagged struct
==================

<constructor>{}
<constructor>{ a, b }
<constructor>{ ['a']: 1, ...b, c: 'str', d, e }

---

(program
  term: (tagged_value
    name: (identifier)
    value: (struct))
  term: (tagged_value
    name: (identifier)
    value: (struct
      member: (shorthand_member)
      member: (shorthand_member)))
  term: (tagged_value
    name: (identifier)
    value: (struct
      member: (member
        key: (string)
        value: (number))
      member: (spread
        value: (identifier))
      member: (member
        key: (shorthand_member_identifier)
        value: (string))
      member: (shorthand_member)
      member: (shorthand_member))))

==================
tuple
==================

()
(a, 1, 'str', ...x)
(1,1)

---

(program
  term: (tuple)
  term: (tuple
    element: (identifier)
    element: (number)
    element: (string)
    element: (spread
      value: (identifier)))
  term: (tuple
    element: (number)
    element: (number)))

==================
tagged tuple
==================

<constructor>()
<constructor>(a, 1, 'str', ...x)
<constructor>(1,1)

---

(program
  term: (tagged_value
    name: (identifier)
    value: (tuple))
  term: (tagged_value
    name: (identifier)
    value: (tuple
      element: (identifier)
      element: (number)
      element: (string)
      element: (spread
        value: (identifier))))
  term: (tagged_value
    name: (identifier)
    value: (tuple
      element: (number)
      element: (number))))

==================
list
==================

[]
[a, 1, ...b, 'str']
[1,1..1,1]

---

(program
  term: (list)
  term: (list
    element: (identifier)
    element: (number)
    element: (spread
      value: (identifier))
    element: (string))
  term: (list
    element: (number)
    element: (infix_application
      left: (number)
      name: (identifier)
      right: (number))
    element: (number)))

==================
tagged list
==================

<constructor>[]
<constructor>[a, 1, ...b, 'str']
<constructor>[1,1..1,1]

---

(program
  term: (tagged_value
    name: (identifier)
    value: (list))
  term: (tagged_value
    name: (identifier)
    value: (list
      element: (identifier)
      element: (number)
      element: (spread
        value: (identifier))
      element: (string)))
  term: (tagged_value
    name: (identifier)
    value: (list
      element: (number)
      element: (infix_application
        left: (number)
        name: (identifier)
        right: (number))
      element: (number))))

==================
list comprehension
==================

[i * 2 | i in 1..10]
[i / 2 | i in 1..10 if i % 2 == 0]
[[x, y] | x in 1..10 if x % 2 == 0, y in 1..10 if i % 2 == 0]

---

(program
  term: (list_comprehension
    body: (block
      term: (infix_application
        left: (identifier)
        name: (identifier)
        right: (number)))
    generator: (generator
      name: (identifier_pattern_name)
      value: (infix_application
        left: (number)
        name: (identifier)
        right: (number))))
  term: (list_comprehension
    body: (block
      term: (infix_application
        left: (identifier)
        name: (identifier)
        right: (number)))
    generator: (generator
      name: (identifier_pattern_name)
      value: (infix_application
        left: (number)
        name: (identifier)
        right: (number))
      condition: (infix_application
        left: (infix_application
          left: (identifier)
          name: (identifier)
          right: (number))
        name: (identifier)
        right: (number))))
  term: (list_comprehension
    body: (block
      term: (list
        element: (identifier)
        element: (identifier)))
    generator: (generator
      name: (identifier_pattern_name)
      value: (infix_application
        left: (number)
        name: (identifier)
        right: (number))
      condition: (infix_application
        left: (infix_application
          left: (identifier)
          name: (identifier)
          right: (number))
        name: (identifier)
        right: (number)))
    generator: (generator
      name: (identifier_pattern_name)
      value: (infix_application
        left: (number)
        name: (identifier)
        right: (number))
      condition: (infix_application
        left: (infix_application
          left: (identifier)
          name: (identifier)
          right: (number))
        name: (identifier)
        right: (number)))))

==================
tagged value
==================

<constructor>'String'
<constructor>1
<constructor>

---

(program
  term: (tagged_value
    name: (identifier)
    value: (string))
  term: (tagged_value
    name: (identifier)
    value: (number))
  term: (tagged_value
    name: (identifier)))

==================
type alias
==================

type Type := Type
type <constructor> Type := Type
type Type<a, b <: Num> := a -> b
type GreaterThan<a>(x :: a) := [y :: a | y > x]

---

(program
  term: (type_alias
    name: (type_declaration
      name: (type))
    type: (parametric_type
      name: (type)))
  term: (type_alias
    name: (type_declaration
      tag: (identifier_pattern_name)
      name: (type))
    type: (parametric_type
      name: (type)))
  term: (type_alias
    name: (type_declaration
      name: (type)
      parameter: (type_variable_declaration
        name: (type_variable_declaration_name))
      parameter: (type_variable_declaration
        name: (type_variable_declaration_name)
        constraint: (parametric_type
          name: (type))))
    type: (curried_type
      from: (type_variable)
      to: (type_variable)))
  term: (type_alias
    name: (type_declaration
      name: (type)
      parameter: (type_variable_declaration
        name: (type_variable_declaration_name))
      element: (identifier_pattern
        name: (identifier_pattern_name)
        type: (type_variable)))
    type: (refinement_type
      generator: (refinement_type_declaration
        name: (identifier_pattern_name)
        type: (type_variable))
      predicate: (infix_application
        left: (identifier)
        name: (identifier)
        right: (identifier)))))

==================
type hint
==================

'string' as String

---

(program
  term: (type_hint
    value: (string)
    type: (parametric_type
      name: (type))))

==================
group
==================

(1)
(n)
(-1)
(-n)
n / ((n + 1) * (-2))

---

(program
  term: (group
    term: (number))
  term: (group
    term: (identifier))
  term: (group
    term: (prefix_application
      name: (identifier)
      value: (number)))
  term: (group
    term: (prefix_application
      name: (identifier)
      value: (identifier)))
  term: (infix_application
    left: (identifier)
    name: (identifier)
    right: (group
      term: (infix_application
        left: (group
          term: (infix_application
            left: (identifier)
            name: (identifier)
            right: (number)))
        name: (identifier)
        right: (group
          term: (prefix_application
            name: (identifier)
            value: (number)))))))