roto 0.10.0

a statically-typed, compiled, embedded scripting language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

%YAML 1.2
---
name: Roto
file_extensions: [roto]
scope: source.roto

variables:
  ident: '\b[_\p{XID_Start}][_\p{XID_Continue}]*\b'
  lower_ident: '\b[[:lower:]][_\p{XID_Continue}]*\b'
  upper_ident: '\b[[:upper:]][_\p{XID_Continue}]*\b'

contexts:
  main:
    - include: base

  base:
    - include: comment
    - include: block
    - include: bool
    - include: type_name
    - include: function_call
    - include: function_def
    - include: keyword
    - include: number
    - include: operator
    - include: punctuation

    - match: '{{lower_ident}}'
      scope: variable.other.roto

    - match: '"'
      push: string

  block:
    - match: '{'
      scope: punctuation.section.block.begin.roto
      push: block_content

  block_content:
    - include: base
    - match: '}'
      scope: punctuation.section.block.end.roto
      pop: true

  type_name:
    - match: \b(u8|u16|u32|u64|i8|i16|i32|i64|f32|f64|bool)\b
      scope: storage.type.roto

    - match: '{{upper_ident}}'
      scope: storage.type.roto

  function_def:
    - match: '\b(fn)(?:[[:space:]]+({{ident}}))?[[:space:]]*\('
      captures:
        1: storage.type.function.roto
        2: entity.name.function.roto
      push: function_def_args

  list:
    - match: '\['
      scope: punctuation.section.sequence.begin.roto
      push: list_body

  list_body:
    - include: base
    - match: '\]'
      scope: punctuation.section.sequence.end.roto
      pop: true

  function_def_args:
    - include: punctuation
    - include: type_name
    - match: '({{ident}})[[:space:]]*:'
      captures:
        1: variable.parameter.roto
    - match: \)
      pop: true

  function_call:
    - match: '({{lower_ident}})\('
      captures:
        1: variable.function.roto
      push: function_call_args

  function_call_args:
    - include: base
    - match: \)
      pop: true

  keyword:
    - match: \b(let)\b
      scope: keyword.declaration.roto

    - match: \b(fn|filter|filtermap|test)\b
      scope: keyword.declaration.function.roto

    - match: \b(if|else|for|while|return|accept|reject|match)\b
      scope: keyword.control.roto

    - match: \b(import)\b
      scope: keyword.control.import.roto

    - match: \b(record)\b
      scope: keyword.declaration.struct.roto

  number:
    - match: '\b[0-9][0-9_]*(\.[0-9]+([eE][+-]?[0-9_]*)?)\b'
      scope: constant.numeric.float.roto

    - match: '\b[0-9][0-9_]*\b'
      scope: constant.numeric.integer.roto

  operator:
    - match: '(<=|>=|==|!=|<|>|<>)'
      scope: keyword.operator.roto
    - match: '='
      scope: keyword.operator.assignment.roto
    - match: '->'
      scope: keyword.operator.roto
    - match: '(\+|\-|/|\*)'
      scope: keyword.operator.arithmetic.roto
    - match: '(&&|\|\|)'
      scope: keyword.operator.logical.roto

  punctuation:
    - match: '\.'
      scope: punctuation.accessor.roto
    - match: ','
      scope: punctuation.separator.roto
    - match: ';'
      scope: punctuation.control.roto

  bool:
    - match: '\b(true|false)\b'
      scope: constant.language.roto

  comment:
    - match: '\#'
      scope: punctuation.definition.comment.roto
      push:
        - meta_scope: comment.line.roto
        - match: \n
          pop: true

  string:
    - meta_scope: string.quoted.double.roto

    - match: '\\.'
      scope: constant.character.escape.roto

    - match: '"'
      pop: true