Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/yoav-lavi/melody

Melody is a language that compiles to regular expressions and aims to be more readable and maintainable
https://github.com/yoav-lavi/melody

compiler language melody melodylang regex regexp regular-expression rust

Last synced: about 1 month ago
JSON representation

Melody is a language that compiles to regular expressions and aims to be more readable and maintainable

Lists

README 

        


  Melody Logo

    Melody Logo






  

    Rust CI

  

  

    Crates.io

  

  

    Crates.io

  

  

    melody playground

  

  

    melody playground

  






Melody is a language that compiles to ECMAScript regular expressions, while aiming to be more readable and maintainable.






  code example




## Examples



Note: these are for the currently supported syntax and may change



### Batman Theme  try in playground



```rust

16 of "na";



2 of match {

  ;

  "batman";

}



// 🦇🦸‍♂️

```



Turns into



```regex

(?:na){16}(?: batman){2}

```



### Twitter Hashtag  try in playground



```rust

"#";

some of ;



// #melody

```



Turns into



```regex

#\w+

```



### Introductory Courses  try in playground



```rust

some of ;

;

"1";

2 of ;



// classname 1xx

```



Turns into



```regex

[a-zA-Z]+ 1\d{2}

```



### Indented Code (2 spaces)  try in playground



```rust

some of match {

  2 of ;

}



some of ;

";";



// let value = 5;

```



Turns into



```regex

(?: {2})+.+;

```



### Semantic Versions  try in playground



```rust

;



option of "v";



capture major {

  some of ;

}



".";



capture minor {

  some of ;

}



".";



capture patch {

  some of ;

}



;



// v1.0.0

```



Turns into



```regex

^v?(?\d+)\.(?\d+)\.(?\d+)$

```



## Playground



You can try Melody in your browser using the [playground](https://melody-playground.vercel.app/)



## Book



Read the book [here](https://yoav-lavi.github.io/melody/book/)



## Install



### Cargo



```sh

cargo install melody_cli

```



### From Source



```sh

git clone https://github.com/yoav-lavi/melody.git

cd melody

cargo install --path crates/melody_cli

```



### Binary



- macOS binaries (`aarch64` and `x86_64`) can be downloaded from the [release page](https://github.com/yoav-lavi/melody/releases)



### Community



- [Brew](https://formulae.brew.sh/formula/melody) (macOS and Linux)

  Installation instructions



  ```sh

  brew install melody

  ```



  



- [Arch Linux](https://aur.archlinux.org/packages/melody) (maintained by [@ilai-deutel](https://github.com/ilai-deutel))

  Installation instructions



  1. Installation with an AUR helper, for instance using `paru`:



     ```bash

     paru -Syu melody

     ```



  2. Install manually with `makepkg`:



     ```bash

     git clone https://aur.archlinux.org/melody.git

     cd melody

     makepkg -si

     ```



  



- [NixOS](https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/misc/melody/default.nix) (maintained by [@jyooru](https://github.com/jyooru))

  Installation instructions



  1. Declarative installation using `/etc/nixos/configuration.nix`:



     ```nix

     { pkgs, ... }:

     {

       environment.systemPackages = with pkgs; [

         melody

       ];

     }

     ```



  2. Imperative installation using `nix-env`:



     ```sh

     nix-env -iA nixos.melody

     ```



  



## CLI Usage



```

USAGE:

    melody [OPTIONS] [INPUT_FILE_PATH]



ARGS:

        Read from a file

                         Use '-' and or pipe input to read from stdin



OPTIONS:

    -f, --test-file 

            Test the compiled regex against the contents of a file



        --generate-completions 

            Outputs completions for the selected shell

            To use, write the output to the appropriate location for your shell



    -h, --help

            Print help information



    -n, --no-color

            Print output with no color



    -o, --output 

            Write to a file



    -r, --repl

            Start the Melody REPL



    -t, --test 

            Test the compiled regex against a string



    -V, --version

            Print version information

```



## Changelog



See the changelog [here](https://github.com/yoav-lavi/melody/blob/main/CHANGELOG.md) or in the [release page](https://github.com/yoav-lavi/melody/releases)



## Syntax



### Quantifiers



- `... of` - used to express a specific amount of a pattern. equivalent to regex `{5}` (assuming `5 of ...`)

- `... to ... of` - used to express an amount within a range of a pattern. equivalent to regex `{5,9}` (assuming `5 to 9 of ...`)

- `over ... of` - used to express more than an amount of a pattern. equivalent to regex `{6,}` (assuming `over 5 of ...`)

- `some of` - used to express 1 or more of a pattern. equivalent to regex `+`

- `any of` - used to express 0 or more of a pattern. equivalent to regex `*`

- `option of` - used to express 0 or 1 of a pattern. equivalent to regex `?`



All quantifiers can be preceded by `lazy` to match the least amount of characters rather than the most characters (greedy). Equivalent to regex `+?`, `*?`, etc.



### Symbols



- `` - matches any single character. equivalent to regex `.`

- `` - matches a space character. equivalent to regex ` `

- `` - matches any kind of whitespace character. equivalent to regex `\s` or `[ \t\n\v\f\r]`

- `` - matches a newline character. equivalent to regex `\n`

- `` - matches a tab character. equivalent to regex `\t`

- `` - matches a carriage return character. equivalent to regex `\r`

- `` - matches a form feed character. equivalent to regex `\f`

- `` - matches a null characther. equivalent to regex `\0`

- `` - matches any single digit. equivalent to regex `\d` or `[0-9]`

- `` - matches a vertical tab character. equivalent to regex `\v`

- `` - matches a word character (any latin letter, any digit or an underscore). equivalent to regex `\w` or `[a-zA-Z0-9_]`

- `` - matches any single latin letter. equivalent to regex `[a-zA-Z]`

- `` - matches any single latin letter or any single digit. equivalent to regex `[a-zA-Z0-9]`

- `` - Matches a character between a character matched by `` and a character not matched by `` without consuming the character. equivalent to regex `\b`

- `` - matches a backspace control character. equivalent to regex `[\b]`



All symbols can be preceeded with `not` to match any character other than the symbol



### Special Symbols



- `` - matches the start of the string. equivalent to regex `^`

- `` - matches the end of the string. equivalent to regex `$`



### Unicode Categories



Note: these are not supported when testing in the CLI (`-t` or `-f`) as the regex engine used does not support unicode categories. These require using the `u` flag.



- `` - any kind of letter from any language

  - `` - a lowercase letter that has an uppercase variant

  - `` - an uppercase letter that has a lowercase variant.

  - `` - a letter that appears at the start of a word when only the first letter of the word is capitalized

  - `` - a letter that exists in lowercase and uppercase variants

  - `` - a special character that is used like a letter

  - `` - a letter or ideograph that does not have lowercase and uppercase variants

- `` - a character intended to be combined with another character (e.g. accents, umlauts, enclosing boxes, etc.)

  - `` - a character intended to be combined with another character without taking up extra space (e.g. accents, umlauts, etc.)

  - `` - a character intended to be combined with another character that takes up extra space (vowel signs in many Eastern languages)

  - `` - a character that encloses the character it is combined with (circle, square, keycap, etc.)

- `` - any kind of whitespace or invisible separator

  - `` - a whitespace character that is invisible, but does take up space

  - `` - line separator character U+2028

  - `` - paragraph separator character U+2029

- `` - math symbols, currency signs, dingbats, box-drawing characters, etc

  - `` - any mathematical symbol

  - `` - any currency sign

  - `` - a combining character (mark) as a full character on its own

  - `` - various symbols that are not math symbols, currency signs, or combining characters

- `` - any kind of numeric character in any script

  - `` - a digit zero through nine in any script except ideographic scripts

  - `` - a number that looks like a letter, such as a Roman numeral

  - `` - a superscript or subscript digit, or a number that is not a digit 0–9 (excluding numbers from ideographic scripts)

- `` - any kind of punctuation character

  - `` - any kind of hyphen or dash

  - `` - any kind of opening bracket

  - `` - any kind of closing bracket

  - `` - any kind of opening quote

  - `` - any kind of closing quote

  - `` - a punctuation character such as an underscore that connects words

  - `` - any kind of punctuation character that is not a dash, bracket, quote or connectors

- `` - invisible control characters and unused code points

  - `` - an ASCII or Latin-1 control character: 0x00–0x1F and 0x7F–0x9F

  - `` - invisible formatting indicator

  - `` - any code point reserved for private use

  - `` - one half of a surrogate pair in UTF-16 encoding

  - `` - any code point to which no character has been assigned



These descriptions are from [regular-expressions.info](https://www.regular-expressions.info/unicode.html)



### Character Ranges



- `... to ...` - used with digits or alphabetic characters to express a character range. equivalent to regex `[5-9]` (assuming `5 to 9`) or `[a-z]` (assuming `a to z`)



### Literals



- `"..."` or `'...'` - used to mark a literal part of the match. Melody will automatically escape characters as needed. Quotes (of the same kind surrounding the literal) should be escaped



### Raw



- \`...\` - added directly to the output without any escaping



### Groups



- `capture` - used to open a `capture` or named `capture` block. capture patterns are later available in the list of matches (either positional or named). equivalent to regex `(...)`

- `match` - used to open a `match` block, matches the contents without capturing. equivalent to regex `(?:...)`

- `either` - used to open an `either` block, matches one of the statements within the block. equivalent to regex `(?:...|...)`



### Assertions



- `ahead` - used to open an `ahead` block. equivalent to regex `(?=...)`. use after an expression

- `behind` - used to open an `behind` block. equivalent to regex `(?<=...)`. use before an expression



Assertions can be preceeded by `not` to create a negative assertion (equivalent to regex `(?!...)`, `(?`                    | `\p{...}`        | 🐣     |

| `not <...::...>`                | `\P{...}`        | 🐣     |

| file watcher                    |                  | ❌     |

| multiline groups in REPL        |                  | ❌     |

| `flags: global, multiline, ...` | `/.../gm...`     | ❔     |

| (?)                             | `\#`             | ❔     |

| (?)                             | `\k`       | ❔     |

| (?)                             | `\uYYYY`         | ❔     |

| (?)                             | `\xYY`           | ❔     |

| (?)                             | `\ddd`           | ❔     |

| (?)                             | `\cY`            | ❔     |

| (?)                             | `$1`             | ❔     |

| (?)                             | $\` | ❔     |

| (?)                             | `$&`             | ❔     |

| (?)                             | `x20`            | ❔     |

| (?)                             | `x{06fa}`        | ❔     |

| `any of "a", "b", "c"` \*       | `[abc]`          | ❓     |

| multiple ranges \*              | `[a-zA-Z0-9]`    | ❓     |

| regex optimization              |                  | ❓     |

| standard library / patterns     |                  | ❓     |

| reverse compiler                |                  | ❓     |



\* these are expressable in the current syntax using other methods