Unified pattern mathing and templates #13

New Issue

2016-11-30T15:21:34Z

SuzanneSoy commented

2016-11-30 15:21:34 +00:00

(Migrated from github.com)

Existing "mainstream" in Racket:

pattern-matching: syntax-case, syntax-parse, match
templating: quote, quasiquote, syntax, quasisyntax, syntax/parse/experimental/template
Parser generators: ragg

Thoughts by other people on matching / templating libraries:

notes by Georges Dupéron
For the typed/racket version, helpers like these could be needed to ensure type inference works with few annotations. Otherwise, trivial could be used to track types in simple cases, to reduce the annotation burden in the most common cases.

Existing minor features which extend syntax/parse, match or templates:

colon-match by Alexander Knauth and Jens Axel Soegaard adds classes to match which work like syntax/parse's syntax classes, e.g. (match 1 [x:nat #t])
kw-make-struct by Alexander Knauth allows using keywords to indicate field names both for struct instantiation and pattern matching
seq-no-order by Alexander Knauth is the syntax-parse equivalent of list-no-order for match
paren-shape-pattern-expanders by Alexander Knauth adds ~parens, ~brackets and ~braces to syntax-parse
match-string by Alexander Knauth allows the use of string-append as a match clause
match-count by Sam Tobin Hochstadt is a profiling tool for match, which counts the number of times each clause matches.
mischief/match by Carl Eastlund includes source locations in the error messages if no clause matches the inputs
plai-match-type is a simple match for use with the PLAI learning language
hash-lookup by Jan Dvořák, a simple hash table descructuring expander compatible with Typed Racket
subtemplate (unpackaged for now) by Georges Dupéron automatically derives gensymed identifiers based on unicode subscripts: (syntax-parse stx [(_ (vᵢ …) f) (subtemplate (let ([tmpᵢ vᵢ] …) (f tmpᵢ …)))) will automatically derive some tmpᵢ identifiers, without the need to manually call generate-temporaries.
auto-syntax-e by Georges Dupéron allows using template pattern variables outside of templates (syntax->datum is implicitly applied to them in that case)
xlist by Georges Dupéron allows superscripts to denote number of repetitions in match patterns and type, e.g. (match '(1 2 3 4 5) [(xlist (? number?)³ b²) b]) ; => '(4 5) and (ann '(1 2 a b c) (xList Number* Symbol³))
extensible-parser-specifications by Georges Dupéron is an unstable library for syntax-parse which allows specifying a partial order between elements within ~no-order, and other global constraints

Feature list:

Unified matching (syntax-parse/match/etc)
Unified templates (syntax, quasiquote, etc)
have as much symmetry as possible between matching patterns and templates, so that when pat and templ are syntactically identical, (unified-match v [pat templ]) acts like the identity function (requested by @jsmaniac)
- self-quoting values should therefore be self-matching (same thing for quoted values):
```
(unified-match 1 [1 #t]) ; => #t
(unified-match 'foo ['foo #t]) ; => #t
(unified-match 3.14 [3.14 #t]) ; => #t
(unified-match '#hash([a 1] [b 2]) ['#hash([b 2] [a 1]) #t]) ; => #t
(unified-match :kw [:kw #t]) ; => #t ;; if keywords are self-quoting
```

If x is a list, then...

support for syntax/parse-like operators in templates

(template (list (~seq 1 ,x) ...))
=>
(append-map (lambda (x) (list 1 x)) x)

templates work both for syntax and regular values

(template (syntax a ,x ... c))
=>
(syntax-cons a (syntax-append x (syntax c)))

Implicit map with …

(template (+ (f ,x) ...))
=>
(apply + (map f x))

Implicit map + destructuring bind with … (requested by @jsmaniac)
(template (define ,y (* ,x ,x)) …)
=>
(match-define (list y …) (map (λ (xᵢ) (* xᵢ xᵢ) x))

Existing "mainstream" in Racket: * pattern-matching: syntax-case, syntax-parse, match * templating: quote, quasiquote, syntax, quasisyntax, syntax/parse/experimental/template * Parser generators: [ragg](http://docs.racket-lang.org/ragg/index.html) Thoughts by other people on matching / templating libraries: * [notes by Georges Dupéron](http://docs.racket-lang.org/phc-toolkit/template-lib.html) * For the typed/racket version, helpers like [these](http://docs.racket-lang.org/typed-map/index.html) could be needed to ensure type inference works with few annotations. Otherwise, [trivial](http://docs.racket-lang.org/trivial/index.html) could be used to track types in simple cases, to reduce the annotation burden in the most common cases. Existing minor features which extend syntax/parse, match or templates: * [colon-match](http://docs.racket-lang.org/colon-match/index.html) by Alexander Knauth and Jens Axel Soegaard adds classes to match which work like syntax/parse's syntax classes, e.g. `(match 1 [x:nat #t])` * [kw-make-struct](http://docs.racket-lang.org/kw-make-struct/index.html) by Alexander Knauth allows using keywords to indicate field names both for struct instantiation and pattern matching * [seq-no-order](http://docs.racket-lang.org/seq-no-order/index.html) by Alexander Knauth is the `syntax-parse` equivalent of `list-no-order` for match * [paren-shape-pattern-expanders](http://docs.racket-lang.org/paren-shape-pattern-expanders/index.html) by Alexander Knauth adds `~parens`, `~brackets` and `~braces` to `syntax-parse` * [match-string](http://docs.racket-lang.org/match-string/index.html) by Alexander Knauth allows the use of `string-append` as a match clause * [match-count](https://github.com/samth/match-count/tree/master/README.md) by Sam Tobin Hochstadt is a profiling tool for `match`, which counts the number of times each clause matches. * [mischief/match](http://docs.racket-lang.org/mischief@mischief/Definitions_and_Binding_Forms.html#%28mod-path._mischief%2Fmatch%29) by Carl Eastlund includes source locations in the error messages if no clause matches the inputs * [plai-match-type](http://docs.racket-lang.org/plai-typed-s-exp-match/index.html) is a simple match for use with the PLAI learning language * [hash-lookup](http://docs.racket-lang.org/misc1/index.html#%28form._%28%28lib._misc1%2Fmatch..rkt%29._hash-lookup%29%29) by Jan Dvořák, a simple hash table descructuring expander compatible with Typed Racket * [subtemplate](https://github.com/jsmaniac/phc-graph/blob/master/subtemplate.rkt) (unpackaged for now) by Georges Dupéron automatically derives `gensym`ed identifiers based on unicode subscripts: `(syntax-parse stx [(_ (vᵢ …) f) (subtemplate (let ([tmpᵢ vᵢ] …) (f tmpᵢ …))))` will automatically derive some tmpᵢ identifiers, without the need to manually call `generate-temporaries`. * [auto-syntax-e]() by Georges Dupéron allows using template pattern variables outside of templates (syntax->datum is implicitly applied to them in that case) * [xlist](http://docs.racket-lang.org/xlist/index.html) by Georges Dupéron allows superscripts to denote number of repetitions in match patterns and type, e.g. `(match '(1 2 3 4 5) [(xlist (? number?)³ b²) b]) ; => '(4 5)` and `(ann '(1 2 a b c) (xList Number* Symbol³))` * [extensible-parser-specifications](http://docs.racket-lang.org/extensible-parser-specifications/index.html) by Georges Dupéron is an unstable library for `syntax-parse` which allows specifying a partial order between elements within `~no-order`, and other global constraints Feature list: - [ ] Unified matching (syntax-parse/match/etc) - [ ] Unified templates (syntax, quasiquote, etc) - [ ] have as much symmetry as possible between matching patterns and templates, so that when `pat` and `templ` are syntactically identical, `(unified-match v [pat templ])` acts like the identity function (requested by @jsmaniac) - [ ] self-quoting values should therefore be self-matching (same thing for quoted values): ```racket (unified-match 1 [1 #t]) ; => #t (unified-match 'foo ['foo #t]) ; => #t (unified-match 3.14 [3.14 #t]) ; => #t (unified-match '#hash([a 1] [b 2]) ['#hash([b 2] [a 1]) #t]) ; => #t (unified-match :kw [:kw #t]) ; => #t ;; if keywords are self-quoting ``` If x is a list, then... - [ ] support for syntax/parse-like operators in templates ```racket (template (list (~seq 1 ,x) ...)) => (append-map (lambda (x) (list 1 x)) x) ``` - [ ] templates work both for syntax and regular values ```racket (template (syntax a ,x ... c)) => (syntax-cons a (syntax-append x (syntax c))) ``` - [ ] Implicit map with `…` ```racket (template (+ (f ,x) ...)) => (apply + (map f x)) ``` - [ ] Implicit map + destructuring bind with `…` (requested by @jsmaniac) (template (define ,y (* ,x ,x)) …) => (match-define (list y …) (map (λ (xᵢ) (* xᵢ xᵢ) x)) ```

SuzanneSoy commented

2016-12-02 18:50:21 +00:00

(Migrated from github.com)

This issue was moved to jeapostrophe/remix#16

Sign in to join this conversation.