def, def*, def+ features overview #4

New Issue

2016-11-30T13:48:44Z

SuzanneSoy commented

2016-11-30 13:48:44 +00:00

(Migrated from github.com)

See also:

mutable-match-lambda by Alexander Knauth
define-match-spread-out by Alexander Knauth
defn and def-jambda by Greg Hendershott
defpat by Alexander Knauth
match-plus by Alexis King allows definition of functions which pattern-match their arguments
multi-id by Georges Dupéron allows giving the same identifier multiple roles (as an identifier macro, macro, type expander, match expander etc.) with a concise syntax

Possible features:

pattern matching

(def (list a (cons b c) d) '(1 (2 . 3) 4))
b ; => 2

Multiple binding forms in one go (requested by Greg: private e-mail):

(def id              42
     (list a b c)    (list 1 2 3)
     (values in out) (tcp-connect "host" 3000))

Define case functions in several chunks:

With pattern-matching

(def+ (f '()) 0)
(def+ (f (cons x l)) {1+ (f l)})

Syntactic sugar haskell-style (requested by Robby):

(haskell-style
 (f '()) = 0
 (f (cons x l)) = {1+ (f l)})

For macros (requested by @jsmaniac):

(def+ [stx (mymacro a:id b:nat)] #''blah)
(def+ [stx (mymacro {~seq x:id y:id} …)] #''blahblah)
(mymacro aa 1) ; => 'blah
(mymacro xx yy xxx yyy xxxx yyyy) ; => 'blahblah

"define"-transformers for attaching meta-information to definitions, like documentation, tests, contracts, types, etc

Give a single identifier multiple meanings (can leverage the multi-id package, requested by @jsmaniac)

(def+ id 42)
(def+ (id a b) (+ a b))
(def+ (id . rest) (append* . rest))
(def+ [stx (id a {~optional b})] #''foo)
(def+ [stx (id . x:id)] #''bar)
(def+ [type-expander (id A)] #'(Pairof A A))
(def+ [match-expander (id A)] #'(cons A A))

id                                ; => 42
(apply id '(1 2))                 ; => '3
(apply id '((1 2) (3 4) (5 6 7))) ; => '(1 2 3 4 5 6 7)
(id 'a 'b)                        ; => 'foo
(id . xxx)                        ; => 'bar
(ann '(1 . 2) (id Number))
(match '(1 . 2)
  [(id (? number?)) #t]
  [_ #f])                         ; => #t

Meta def & def* trans for more expansion (docs and test), static info (types), and def transformers (types), maybe syntax — transformer (can change define to define-syntax/etc) vs expander
(expands to a different syntax) — no ability to add args to functions! — See private e-mail

def+'s default is to use match (while def/def*'s default is to not use match)

(def+ (length '())
  0)
(def+ (length (cons x xs))
  {(length xs) + 1})
(def+ [contract length] (-> list? nat?))
(def+ [doc (length l)]
  @{A most excellent function
    for discovering the length of lists.})
(def+ [examples length]
 {(length '()) \defs 0}
 {(length '(a b c)) \defs 3})
(def+ [provide length])

Question by @jsmaniac: why not use match everywhere (i.e. in def/def* too)?

Syntactic sugar using =:

#lang remix
a b = (values 1 2)
c (d . e) = (values 3 (cons 4 5))
(let x y = (values 1 2)
     z (t w) = (values 3 (cons 4 5))
     in ;; optional, just for clarity
        ;; and disables use of `=` as a binding form after the `in`
     (+ x y z t w)) ;; => 15
(def+ (f x y)
  a = {x + y}
  b = {x - y}
  (* a b))
(f 4 6) ;; => -20

See also: * [mutable-match-lambda](http://docs.racket-lang.org/mutable-match-lambda/index.html) by Alexander Knauth * [define-match-spread-out](http://docs.racket-lang.org/define-match-spread-out/index.html) by Alexander Knauth * [defn](https://github.com/greghendershott/defn) and [def-jambda](https://github.com/greghendershott/def-jambda) by Greg Hendershott * [defpat](http://docs.racket-lang.org/defpat-main/index.html) by Alexander Knauth * [match-plus](http://docs.racket-lang.org/match-plus/index.html) by Alexis King allows definition of functions which pattern-match their arguments * [multi-id](http://docs.racket-lang.org/multi-id/index.html) by Georges Dupéron allows giving the same identifier multiple roles (as an identifier macro, macro, type expander, match expander etc.) with a concise syntax Possible features: * pattern matching ```racket (def (list a (cons b c) d) '(1 (2 . 3) 4)) b ; => 2 ``` * Multiple binding forms in one go (requested by Greg: [private e-mail](https://mail.google.com/mail/u/0/#inbox/1574317e1974dbf5)): ```racket (def id 42 (list a b c) (list 1 2 3) (values in out) (tcp-connect "host" 3000)) ``` * Define case functions in several chunks: * With pattern-matching ```racket (def+ (f '()) 0) (def+ (f (cons x l)) {1+ (f l)}) ``` * Syntactic sugar haskell-style (requested by Robby): ```racket (haskell-style (f '()) = 0 (f (cons x l)) = {1+ (f l)}) ``` * For macros (requested by @jsmaniac): ```racket (def+ [stx (mymacro a:id b:nat)] #''blah) (def+ [stx (mymacro {~seq x:id y:id} …)] #''blahblah) (mymacro aa 1) ; => 'blah (mymacro xx yy xxx yyy xxxx yyyy) ; => 'blahblah ``` * "define"-transformers for attaching meta-information to definitions, like documentation, tests, contracts, types, etc * Give a single identifier multiple meanings (can leverage the multi-id package, requested by @jsmaniac) ```racket (def+ id 42) (def+ (id a b) (+ a b)) (def+ (id . rest) (append* . rest)) (def+ [stx (id a {~optional b})] #''foo) (def+ [stx (id . x:id)] #''bar) (def+ [type-expander (id A)] #'(Pairof A A)) (def+ [match-expander (id A)] #'(cons A A)) id ; => 42 (apply id '(1 2)) ; => '3 (apply id '((1 2) (3 4) (5 6 7))) ; => '(1 2 3 4 5 6 7) (id 'a 'b) ; => 'foo (id . xxx) ; => 'bar (ann '(1 . 2) (id Number)) (match '(1 . 2) [(id (? number?)) #t] [_ #f]) ; => #t ``` * Meta def & def* trans for more expansion (docs and test), static info (types), and def transformers (types), maybe syntax — transformer (can change define to define-syntax/etc) vs expander (expands to a different syntax) — no ability to add args to functions! — See [private e-mail](https://mail.google.com/mail/u/0/#inbox/1513f480b3313fb2) * def+'s default is to use match (while def/def*'s default is to not use match) ```racket (def+ (length '()) 0) (def+ (length (cons x xs)) {(length xs) + 1}) (def+ [contract length] (-> list? nat?)) (def+ [doc (length l)] @{A most excellent function for discovering the length of lists.}) (def+ [examples length] {(length '()) \defs 0} {(length '(a b c)) \defs 3}) (def+ [provide length]) ``` * Question by @jsmaniac: why not use match everywhere (i.e. in def/def* too)? * Syntactic sugar using `=`: ```racket #lang remix a b = (values 1 2) c (d . e) = (values 3 (cons 4 5)) (let x y = (values 1 2) z (t w) = (values 3 (cons 4 5)) in ;; optional, just for clarity ;; and disables use of `=` as a binding form after the `in` (+ x y z t w)) ;; => 15 (def+ (f x y) a = {x + y} b = {x - y} (* a b)) (f 4 6) ;; => -20 ```

SuzanneSoy commented

2016-12-02 18:49:19 +00:00

(Migrated from github.com)

This issue was moved to jeapostrophe/remix#7

Sign in to join this conversation.