milone.json

{
    "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
    "version": "0.4.0",
    "name": "milone",
    "scopeName": "source.milone",
    "patterns": [
        {
            "include": "#milone_syntax"
        }
    ],
    "repository": {
        "milone_syntax": {
            "comment": "The root rule of the milone-lang syntax. Note that this rule assumes value context where identifiers can be either values and types unlike 'type_rule' and 'pattern_rule'.",
            "patterns": [
                {
                    "include": "#comment_rule"
                },
                {
                    "include": "#literal_rule"
                },
                {
                    "include": "#unsupported_token_rule"
                },
                {
                    "include": "#type_declaration_rule"
                },
                {
                    "include": "#type_argument_list_in_value_rule"
                },
                {
                    "include": "#type_ascription_rule"
                },
                {
                    "include": "#match_arm_rule"
                },
                {
                    "include": "#closure_rule"
                },
                {
                    "include": "#let_fun_rule"
                },
                {
                    "include": "#let_val_rule"
                },
                {
                    "include": "#keyword_rule"
                },
                {
                    "include": "#built_in_value_rule"
                },
                {
                    "comment": "Rule of attributes (`[< ... >]`). Well-known attribute names are recognized inside of attributes. This rule doesn't check if it's a valid place for the attribute to occur nor an appreciate syntax element follows it.",
                    "begin": "(\\[<)",
                    "end": "(>\\])",
                    "beginCaptures": {
                        "1": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "endCaptures": {
                        "1": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "patterns": [
                        {
                            "name": "entity.other.attribute-name.milone",
                            "match": "\\b(Repr)\\b"
                        },
                        {
                            "include": "#milone_syntax"
                        }
                    ]
                },
                {
                    "comment": "Rule of sigils in value context. Sigils include brackets, operators and punctuations. This rule must be after the 'unsupported_token_rule' for precedence.",
                    "patterns": [
                        {
                            "comment": "Rule of arrows in match arms. Trailing negative lookahead (?!) ensures no other operator-sigils follow it. Other rules such as closure_rule override this rule for `->` of the different meaning.",
                            "name": "keyword.control.milone",
                            "match": "(->)(?![-;:!?\\.@*\\/&%^+<=>|~])"
                        },
                        {
                            "comment": "Rule of arithmetic operators. (+ - * / % &&& ||| ^^^ <<< >>>) Trailing negative lookahead (?!) ensures no other operator-sigils follow it. This rule must be after the arrow rule for precedence.",
                            "name": "keyword.operator.arithmetic.milone",
                            "match": "(\\+|-|\\*|/|%|&&&|\\|\\|\\||\\^\\^\\^|<<<|>>>)(?![-;:!?\\.@*\\/&%^+<=>|~])"
                        },
                        {
                            "comment": "Rule of logical operators (&& ||). Trailing negative lookahead (?!) ensures no other operator-sigils follow it.",
                            "name": "keyword.operator.logical.milone",
                            "match": "(&&|\\|\\|)(?![-;:!?\\.@*\\/&%^+<=>|~])"
                        },
                        {
                            "comment": "Rule of other operators and punctuations: (|> .. . :: & | , ;). Trailing negative lookahead (?!) ensures no other operator-sigils follow it. ':' is recognized in the type ascription rule.",
                            "name": "keyword.operator.other.milone",
                            "match": "(\\|>|\\.\\.?|::|&|\\||,|;)(?![-;:!?\\.@*\\/&%^+<=>|~])"
                        },
                        {
                            "comment": "Rule of comparison operators. Trailing negative lookahead (?!) ensures no other operator-sigils follow it.",
                            "name": "keyword.operator.comparison.milone",
                            "match": "(=|<>|<|<=|>|>=)(?![-;:!?\\.@*\\/&%^+<=>|~])"
                        },
                        {
                            "include": "#unknown_sigil_rule"
                        },
                        {
                            "comment": "Rule of brackets: () [] {}. This rule must be after the 'unsupported_token_rule' for precedence.",
                            "name": "keyword.operator.bracket.milone",
                            "match": "\\(|\\)|\\[|\\]|\\{|\\}"
                        }
                    ]
                },
                {
                    "include": "#namespace_guess_rule"
                }
            ]
        },
        "comment_rule": {
            "comment": "Rule of comments. Almost all of rules should include this rule.",
            "patterns": [
                {
                    "comment": "Single-line documentation comment",
                    "name": "comment.line.documentation.milone",
                    "begin": "///",
                    "end": "$"
                },
                {
                    "comment": "Single-line non-documentation comment",
                    "name": "comment.line.double-slash.milone",
                    "begin": "//",
                    "end": "$"
                }
            ]
        },
        "literal_rule": {
            "comment": "Rule of literals: numbers, chars, type variables, strings, unit and booleans. Almost all of rules should include this rule because interpretation of these tokens is independent of context.",
            "patterns": [
                {
                    "comment": "Rule of hex literals. Structure is: `'0x' <ident>`. This rule allows non-hex letters because of suffix and interleaving `_`s.",
                    "name": "constant.numeric.hexadecimal.milone",
                    "match": "\\b(0x[_\\w]*)\\b"
                },
                {
                    "comment": "Rule of decimal literals: both integers and floats. Structure is: `-?<int>(<fraction>?)(<exp>?)(<suffix>?)`, allowing interleaving `_`s.",
                    "name": "constant.numeric.float.milone",
                    "match": "(-|\\b)[0-9][_0-9]*(\\.[_0-9]*)?([eE][-+]?[_0-9]*)?\\w*\\b"
                },
                {
                    "comment": "Rule of char literals. Structure is basically: `'(<char>|<escape>)' <suffix>`. Suffix is marked as illegal.",
                    "name": "string.quoted.single.milone",
                    "match": "'([^'\\\\]|\\\\(?:x[0-9A-Fa-f]{2}|.))'(\\w*)",
                    "captures": {
                        "1": {
                            "patterns": [
                                {
                                    "include": "#escape_sequence_rule"
                                }
                            ]
                        },
                        "2": {
                            "name": "invalid.illegal.milone"
                        }
                    }
                },
                {
                    "comment": "Rule of type variables. This rule must be after the char literal rule for precedence.",
                    "name": "entity.name.type.variable.milone",
                    "match": "'[A-Za-z]\\b"
                },
                {
                    "comment": "Rule of invalid type variables; e.g. '_, 'xx, ^static. This rule must be after the char literal rule and the valid type variable rule for precedence.",
                    "name": "invalid.illegal.milone",
                    "match": "('_|'[_A-Za-z]\\w+|\\^[_A-Za-z]\\w*)\\b"
                },
                {
                    "comment": "Rule of multiline string literals. This also marks suffix as illegal.",
                    "name": "string.quoted.triple.milone",
                    "begin": "\"\"\"",
                    "end": "\"\"\"(\\w*)",
                    "endCaptures": {
                        "1": {
                            "name": "invalid.illegal.milone"
                        }
                    }
                },
                {
                    "comment": "Rule of illegal prefix of char/string literals. This rule visualizes that identifiers and quotes shouldn't appear consecutively with no spaces for forward compatibility.",
                    "name": "invalid.illegal.milone",
                    "match": "\\b([_A-Za-z]\\w*)(?=['\"])"
                },
                {
                    "comment": "Rule of single-line string literals. This also marks suffix as illegal.",
                    "name": "string.quoted.double.milone",
                    "begin": "\"",
                    "end": "\"(\\w*)",
                    "endCaptures": {
                        "1": {
                            "name": "invalid.illegal.milone"
                        }
                    },
                    "patterns": [
                        {
                            "include": "#escape_sequence_rule"
                        }
                    ]
                },
                {
                    "comment": "Rule of the unit literal and bool literals",
                    "name": "constant.language.literal.milone",
                    "match": "\\(\\)|\\b(false|true)\\b"
                },
                {
                    "comment": "Rule of quoted identifiers.",
                    "name": "entity.name.quoted.double-backtick.milone",
                    "begin": "``",
                    "end": "``"
                }
            ]
        },
        "escape_sequence_rule": {
            "comment": "Rule of escape sequences in quotes.",
            "name": "constant.character.escape.milone",
            "match": "\\\\(x[0-9A-Fa-f]{2}|.)"
        },
        "keyword_rule": {
            "comment": "Rule of non-contextual keywords. Almost all of rules should include this rule because these keywords work anywhere. Be careful of the include order for precedence.",
            "patterns": [
                {
                    "name": "keyword.control.milone",
                    "match": "\\b(else|if|match|then|when|with)\\b"
                },
                {
                    "name": "storage.modifier.visibility.milone",
                    "match": "\\b(private|public)\\b"
                },
                {
                    "name": "keyword.other.milone",
                    "match": "\\b(_|as|fun|in|let|module|of|open|rec|type)\\b"
                }
            ]
        },
        "built_in_value_rule": {
            "comment": "Rule of built-in value names: functions and variants. These are non-keywords.",
            "patterns": [
                {
                    "name": "entity.name.function.milone",
                    "match": "\\b(assert|box|char|compare|exit|float(32)?|fst|id|not|printfn|s?byte|sizeof|snd|string|u?int(8|16|32|64)?|u?nativeint|unbox|__\\w*)\\b"
                },
                {
                    "name": "entity.name.variant.milone",
                    "match": "\\b(Error|None|Ok|Some)\\b"
                }
            ]
        },
        "unsupported_token_rule": {
            "comment": "Rule of unsupported brackets, operators, punctuations and non-contextual keywords. This includes: Banana brackets (||), arrays [||], blocks [::], anonymous records {||}, OCaml-style comments (**) and unusable sigils (\\ # ` $). Almost all of rules should include this rule because these tokens are rejected anywhere. Include this rule earlier order for precedence. Define supported sigils and keywords after this rule. Include also 'keyword_rule' for supported keywords.",
            "patterns": [
                {
                    "name": "invalid.illegal.milone",
                    "match": "\\(\\||\\|\\)|\\[\\||\\|\\]|\\[:|:\\]|\\{\\||\\|\\}|\\(\\*|\\*\\)|\\\\|#|`|\\$"
                },
                {
                    "comment": "Rule of unsupported computation expression binders.",
                    "name": "invalid.illegal.milone",
                    "match": "\\b(do|let|match|return|yield)!"
                },
                {
                    "comment": "Rule of unsupported keywords.",
                    "name": "invalid.illegal.milone",
                    "match": "\\b(abstract|and|async|base|become|begin|break|checked|class|component|const|constraint|continue|default|delegate|done|downcast|downto|do|elif|end|event|exception|extern|external|finally|fixed|for|function|global|include|inherit|inline|interface|internal|lazy|member|mixin|mutable|mut|namespace|new|null|or|override|parallel|process|protected|pure|ref|return|sealed|select|seq|signature|sig|static|struct|tailcall|to|trait|try|upcast|use|val|virtual|void|while|yield)\\b"
                }
            ]
        },
        "unknown_sigil_rule": {
            "comment": "Rule of unknown sigils. Except for defined sigils in other rules, all combination of operator-sigils are invalid for backward compatibility with F# custom operators.",
            "name": "invalid.illegal.operator.milone",
            "match": "[-;:!?\\.@*\\/&%^+<=>|~]+"
        },
        "type_argument_list_in_value_rule": {
            "comment": "Rule of identifiers followed by a type argument list. Structure is: `<ident> ('.' <id>)* '<' ... '>'`. The left angle bracket may not be lead by spaces. Only value-context rules should include this rule. Type-context rules should use 'type_argument_list_in_type_rule' instead.",
            "begin": "\\b([_A-Za-z]\\w*(?:\\.[_A-Za-z]\\w*)*)(<)",
            "end": ">",
            "beginCaptures": {
                "1": {
                    "patterns": [
                        {
                            "include": "#keyword_rule"
                        },
                        {
                            "include": "#built_in_value_rule"
                        },
                        {
                            "include": "#namespace_guess_rule"
                        }
                    ]
                },
                "2": {
                    "name": "keyword.operator.bracket.milone"
                }
            },
            "endCaptures": {
                "0": {
                    "name": "keyword.operator.bracket.milone"
                }
            },
            "patterns": [
                {
                    "include": "#type_rule"
                }
            ]
        },
        "type_argument_list_in_type_rule": {
            "comment": "Rules of identifiers followed by a type argument list in type context. Structure is: `<ident> ('.' <id>)* '<' ... '>'`. The left angle bracket may not be lead by spaces. Only type-context rules should include this rule. Value-context rules should use 'type_argument_list_in_value_rule' instead.",
            "begin": "\\b([_A-Za-z]\\w*(?:\\.[_A-Za-z]\\w*)*)(<)",
            "end": ">",
            "beginCaptures": {
                "1": {
                    "patterns": [
                        {
                            "include": "#type_rule"
                        }
                    ]
                },
                "2": {
                    "name": "keyword.operator.bracket.milone"
                }
            },
            "endCaptures": {
                "0": {
                    "name": "keyword.operator.bracket.milone"
                }
            },
            "patterns": [
                {
                    "include": "#type_rule"
                }
            ]
        },
        "type_ascription_rule": {
            "comment": "Rule of type ascriptions and payload type declarations. Structure is: `(':' | 'of') <type>`.",
            "patterns": [
                {
                    "comment": "Rule of normal type ascriptions. Trailing negative lookahead (?!) ensures no other operator-sigils follow it. Ending anchor looks ahead for any right bracket or one of `= | , ;`.",
                    "begin": "(:)(?![-;:!?\\.@*\\/&%^+<=>|~])",
                    "end": "(?=\\)|\\]|\\}|=|\\||,|;)|$",
                    "beginCaptures": {
                        "1": {
                            "name": "keyword.operator.milone"
                        }
                    },
                    "patterns": [
                        {
                            "include": "#type_rule"
                        }
                    ]
                },
                {
                    "comment": "Rule of payload type declarations. Label specifiers are recognized inside of this rule (`<ident> ':'`).",
                    "begin": "\\b(of)\\b",
                    "end": "(?=\\|)|$",
                    "beginCaptures": {
                        "1": {
                            "name": "keyword.other.milone"
                        }
                    },
                    "patterns": [
                        {
                            "match": "\\b([_A-Za-z]\\w*)\\b\\s*(:)(?![-;:!?\\.@*\\/&%^+<=>|~])",
                            "captures": {
                                "1": {
                                    "name": "entity.name.label.milone"
                                },
                                "2": {
                                    "name": "keyword.operator.milone"
                                }
                            }
                        },
                        {
                            "include": "#type_rule"
                        }
                    ]
                }
            ]
        },
        "type_rule": {
            "comment": "Rule of the type context in the milone-lang syntax. This excludes rules of values and declarations. Uppercase identifiers are type names by default.",
            "patterns": [
                {
                    "include": "#comment_rule"
                },
                {
                    "include": "#literal_rule"
                },
                {
                    "include": "#unsupported_token_rule"
                },
                {
                    "include": "#type_argument_list_in_type_rule"
                },
                {
                    "include": "#keyword_rule"
                },
                {
                    "comment": "This rule is included for variant declarations.",
                    "include": "#match_arm_rule"
                },
                {
                    "comment": "Rule of sigils in types: `* -> . , ;`. Trailing negative lookahead (?!) ensures no other operator-sigils follow it.",
                    "name": "keyword.operator.type.milone",
                    "match": ",|(\\*|->|\\.|;)(?![-;:!?\\.@*\\/&%^+<=>|~])"
                },
                {
                    "comment": "Rule of paren types. This rule allows type context spans over multiline.",
                    "begin": "\\(",
                    "end": "\\)",
                    "beginCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "endCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "patterns": [
                        {
                            "include": "#type_rule"
                        }
                    ]
                },
                {
                    "comment": "Rule of record types. This rule is defined for the case where a record type declaration occur in the right-hand side of a type declaration. The 'type_ascription_rule' can handle field declarations.",
                    "begin": "\\{",
                    "end": "\\}",
                    "beginCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "endCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "patterns": [
                        {
                            "include": "#type_ascription_rule"
                        },
                        {
                            "include": "#type_rule"
                        }
                    ]
                },
                {
                    "comment": "Rule of nav types. Structure is: `<ident> ('.' <ident>)+`. Only type-context rules should include this rule.",
                    "patterns": [
                        {
                            "match": "\\b([A-Za-z]\\w*)(?:(\\.)([A-Za-z]\\w*))+\\b",
                            "captures": {
                                "1": {
                                    "name": "entity.name.namespace.milone"
                                },
                                "2": {
                                    "name": "keyword.operator.milone"
                                },
                                "3": {
                                    "name": "entity.name.type.milone"
                                }
                            }
                        }
                    ]
                },
                {
                    "comment": "Rule of identifiers in type context. Type name starts with an upper alphabet or one of built-in type names.",
                    "name": "entity.name.type.milone",
                    "match": "\\b([A-Z]\\w*|bool|char|float(32)?|list|nativeptr|obj|option|s?byte|sizeof|string|u?int(8|16|32|64)?|u?nativeint|unit|voidptr|__nativeType|__inptr|__outptr|__voidinptr)\\b"
                },
                {
                    "include": "#unknown_sigil_rule"
                }
            ]
        },
        "pattern_rule": {
            "comment": "Rule of the pattern context in the milone-lang syntax. This excludes rules of declarations. Uppercase identifiers are assumed to be variants.",
            "patterns": [
                {
                    "include": "#comment_rule"
                },
                {
                    "include": "#literal_rule"
                },
                {
                    "include": "#unsupported_token_rule"
                },
                {
                    "include": "#type_ascription_rule"
                },
                {
                    "include": "#keyword_rule"
                },
                {
                    "comment": "Rule of paren patterns. This rule allows pattern context spans over multiline.",
                    "begin": "\\(",
                    "end": "\\)",
                    "beginCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "endCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "patterns": [
                        {
                            "include": "#pattern_rule"
                        }
                    ]
                },
                {
                    "comment": "Rule of list patterns. This rule allows pattern context spans over multiline.",
                    "begin": "\\[",
                    "end": "\\]",
                    "beginCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "endCaptures": {
                        "0": {
                            "name": "keyword.operator.bracket.milone"
                        }
                    },
                    "patterns": [
                        {
                            "include": "#pattern_rule"
                        }
                    ]
                },
                {
                    "comment": "Rule of operators and sigils in patterns. Trailing negative lookahead (?!) ensures no other operator-sigils follow it.",
                    "name": "keyword.operator.pattern.milone",
                    "match": ",|(-|::|\\||\\.|;)(?![-;:!?\\.@*\\/&%^+<=>|~])"
                },
                {
                    "include": "#namespace_guess_rule"
                },
                {
                    "comment": "Rule of lowercase identifiers.",
                    "name": "variable.name.pattern.milone",
                    "match": "\\b([a-z]\\w*)\\b"
                },
                {
                    "comment": "Rule of uppercase identifiers that are assumed to be variants.",
                    "name": "entity.name.variant.milone",
                    "match": "\\b([A-Z]\\w*)\\b"
                },
                {
                    "comment": "Rule of conventional wildcard identifiers.",
                    "name": "variable.name.wildcard.milone",
                    "match": "\\b(_\\w*)\\b"
                },
                {
                    "include": "#unknown_sigil_rule"
                }
            ]
        },
        "match_arm_rule": {
            "comment": "Rule of match arms and variant declarations. These syntaxes can't be distinct in the textmate syntax definition (if I understand correctly). Structure is: `'|' <pattern> ('->' | '|' | $)`.",
            "begin": "(\\|)(?![-;:!?\\.@*\\/&%^+<=>|~])",
            "end": "(?:(->)|(?=\\|))(?![-;:!?\\.@*\\/&%^+<=>|~])|$",
            "beginCaptures": {
                "1": {
                    "name": "keyword.operator.milone"
                }
            },
            "endCaptures": {
                "1": {
                    "name": "keyword.control.operator.milone"
                },
                "2": {
                    "name": "keyword.operator.milone"
                }
            },
            "patterns": [
                {
                    "begin": "\\b(?=when)\\b",
                    "end": "(?=(->|\\|)(?![-;:!?\\.@*\\/&%^+<=>|~]))|$",
                    "patterns": [
                        {
                            "include": "#milone_syntax"
                        }
                    ]
                },
                {
                    "include": "#type_ascription_rule"
                },
                {
                    "include": "#pattern_rule"
                }
            ]
        },
        "closure_rule": {
            "comment": "Rule of closure expressions. This rule overrides the rule of `->` that is for match arms by default. Structure is: `'fun' <pattern>+ '->'`.",
            "begin": "\\b(fun)\\b",
            "end": "(->)(?![-;:!?\\.@*\\/&%^+<=>|~])|$",
            "beginCaptures": {
                "1": {
                    "name": "keyword.other.milone"
                }
            },
            "endCaptures": {
                "1": {
                    "name": "keyword.other.milone"
                }
            },
            "patterns": [
                {
                    "include": "#pattern_rule"
                }
            ]
        },
        "let_fun_rule": {
            "comment": "Rule of let-fun expressions and declarations. Structure is: `'let' 'rec'? vis? ident ('<' ... '>')?`, followed by a parameter pattern. Negative lookahead (?!) ensures the identifier can't be a keyword. This rule is defined to recognize function names for better readability and visual distinction to the let-val syntax.",
            "begin": "\\b(let)\\b\\s*(?:(rec)\\b\\s*)?(?:(private|public)\\b\\s*)?(?!rec|private|public)([A-Za-z]\\w*)\\b(?:(<)([^=\\r\\n]*)(>))?\\s*(?=\\w|\\()",
            "end": "(=)|$",
            "beginCaptures": {
                "1": {
                    "name": "keyword.other.milone"
                },
                "2": {
                    "name": "keyword.other.milone"
                },
                "3": {
                    "name": "storage.modifier.visibility.milone"
                },
                "4": {
                    "name": "entity.name.function.milone"
                },
                "5": {
                    "name": "keyword.operator.bracket.milone"
                },
                "6": {
                    "patterns": [
                        {
                            "include": "#type_rule"
                        }
                    ]
                },
                "7": {
                    "name": "keyword.operator.bracket.milone"
                }
            },
            "endCaptures": {
                "1": {
                    "name": "keyword.other.milone"
                }
            },
            "patterns": [
                {
                    "include": "#pattern_rule"
                }
            ]
        },
        "let_val_rule": {
            "comment": "Rule of let-val expressions and declarations. Structure is: `'let' <pattern> '='`.",
            "begin": "\\b(let)\\b",
            "end": "(=)",
            "beginCaptures": {
                "1": {
                    "name": "keyword.other.milone"
                }
            },
            "endCaptures": {
                "1": {
                    "name": "keyword.other.milone"
                }
            },
            "patterns": [
                {
                    "include": "#pattern_rule"
                }
            ]
        },
        "type_declaration_rule": {
            "comment": "Rule of type declarations. Structure is: `'type' vis? 'ident' '<' ... '>' '=' ...`. This rule is defined to make the right-hand side be in type context. This rule spans only single line and doesn't handle multiline type declarations (typically for union and records) correctly; although it looks good enough thanks to the type ascription rule handles variant declarations and field declarations.",
            "begin": "\\b(type)\\b\\s*((?:private|public)\\b\\s*)?([A-Za-z]\\w*\\b(?:<[^=\\r\\n]*>)?)\\s*(=)",
            "end": "$",
            "beginCaptures": {
                "1": {
                    "name": "keyword.other.milone"
                },
                "2": {
                    "name": "storage.modifier.visibility.milone"
                },
                "3": {
                    "patterns": [
                        {
                            "include": "#type_rule"
                        }
                    ]
                },
                "4": {
                    "name": "keyword.other.milone"
                }
            },
            "patterns": [
                {
                    "include": "#type_rule"
                }
            ]
        },
        "namespace_guess_rule": {
            "comment": "Rule of namespace-ish symbols guess (uppercase, front of dot.)",
            "match": "\\b([A-Z]\\w*)(?=\\.(?!\\.|\\[))",
            "captures": {
                "1": {
                    "name": "entity.name.namespace.milone"
                }
            }
        }
    }
}