Unicode lambda

typed-racket-compatibility/typed/scheme/base.rkt

@@ -4,7 +4,7 @@
                          with-handlers with-handlers* default-continuation-prompt-tag
                          define λ lambda define-struct for for*
                          let let* let-values let*-values letrec letrec-values
-                         let/cc let/ec do case-lambda
+                         let/cc let/ec do case-lambda case-λ
                          for/list for/vector for/hash for/hasheq for/hasheqv for/hashalw
                          for/and for/or for/sum for/product for/lists
                          for/first for/last for/fold for/foldr for*/list for*/lists

typed-racket-doc/typed-racket/scribblings/reference/legacy.scrbl

@@ -27,31 +27,40 @@ A function of the formal arguments @racket[v], where each formal
 argument has the associated type.  If a rest argument is present, then
 it has type @racket[(Listof t)].}
 
-@defform[(λ: formals maybe-ret . body)]{
-An alias for the same form using @racket[lambda:].}
+@defalias[λ: lambda: "syntax"]
 
 @defform*[[(plambda: (a ...) formals maybe-ret . body)
            (plambda: (a ... b ooo) formals maybe-ret . body)]]{
 A polymorphic function, abstracted over the type variables
 @racket[a]. The type variables @racket[a] are bound in both the types
 of the formal, and in any type expressions in the @racket[body].}
 
+@defalias[pλ: plambda: "syntax"]
+
 @defform/subs[(opt-lambda: formals maybe-ret . body)
 ([formals ([v : t] ... [v : t default] ...)
           ([v : t] ... [v : t default] ... v : t *)
           ([v : t] ... [v : t default] ... v : t ooo bound)])]{
 A function with optional arguments.}
 
+@defalias[opt-λ: opt-lambda: "syntax"]
+
 @defform*[[(popt-lambda: (a ...) formals maybe-ret . body)
            (popt-lambda: (a ... a ooo) formals maybe-ret . body)]]{
 A polymorphic function with optional arguments.}
 
+@defalias[popt-λ: popt-lambda: "syntax"]
+
 @defalias[case-lambda: case-lambda "syntax"]
 
+@defalias[case-λ: case-lambda: "syntax"]
+
 @defform*[[(pcase-lambda: (a ...) [formals body] ...)
            (pcase-lambda: (a ... b ooo) [formals body] ...)]]{
 A polymorphic function of multiple arities.}
 
+@defalias[pcase-λ: pcase-lambda: "syntax"]
+
 @defform*[[
   (let: ([v : t e] ...) . body)
   (let: loop : t0 ([v : t e] ...) . body)]]{

typed-racket-doc/typed-racket/scribblings/reference/special-forms.scrbl

@@ -189,8 +189,7 @@ is the provided type annotation.
 ]
 }
 
-@defform[(λ maybe-tvars formals maybe-ret . body)]{
-An alias for the same form using @racket[lambda].}
+@defalias[λ lambda "syntax"]
 
 @defform[(case-lambda maybe-tvars [formals body] ...)]{
 
@@ -214,6 +213,8 @@ Note that each @racket[formals] must have a different arity.
 To see how to declare a type for @racket[add-map], see the
 @racket[case->] type constructor.}
 
+@defalias[case-λ case-lambda "syntax"]
+
 @section{Loops}
 
 @defform/subs[(for void-ann-maybe (for-clause ...) void-ann-maybe expr ...+)

typed-racket-lib/typed-racket/base-env/prims-lambda.rkt

@@ -17,7 +17,13 @@
 
 (provide (rename-out [-case-lambda case-lambda]
                      [-case-lambda case-lambda:]
-                     [lambda: λ:])
+                     [-case-lambda case-λ]
+                     [-case-lambda case-λ:]
+                     [pcase-lambda: pcase-λ:]
+                     [plambda: pλ:]
+                     [lambda: λ:]
+                     [popt-lambda: popt-λ:]
+                     [opt-lambda: opt-λ:])
          pcase-lambda:
          plambda:
          -lambda

typed-racket-lib/typed-racket/private/with-types.rkt

@@ -28,7 +28,7 @@
           (except-in racket/base for for* with-handlers with-handlers*
                      lambda λ define
                      let let* letrec letrec-values let-values let*-values
-                     let/cc let/ec do case-lambda struct define-struct
+                     let/cc let/ec do case-lambda case-λ struct define-struct
                      default-continuation-prompt-tag
                      for/list for/vector for/hash for/hasheq for/hasheqv for/hashalw
                      for/and for/or for/sum for/product for/lists

typed-racket-lib/typed/racket/base.rkt

@@ -4,7 +4,7 @@
                          with-handlers with-handlers* default-continuation-prompt-tag
                          define λ lambda define-struct for for*
                          let let* let-values let*-values letrec letrec-values
-                         let/cc let/ec do case-lambda struct
+                         let/cc let/ec do case-lambda case-λ struct
                          for/list for/vector for/hash for/hasheq for/hasheqv for/hashalw
                          for/and for/or for/sum for/product for/lists
                          for/first for/last for/fold for/foldr for*/list for*/lists

typed-racket-test/succeed/unicode-aliases.rkt

@@ -1,8 +1,27 @@
 #lang typed/racket/base
 
-(: foo (→* ((∪ Symbol String)) (Integer) (Pair Boolean Integer)))
-(define foo
-  (λ (s [i 0])
-    (cons (symbol? s) i)))
-(foo 'abc)
-(foo "abc")
+(: foo0 (∀ () (→* ((∪ Symbol String)) (Integer) (Pair Boolean Integer))))
+(: foo1 (∀ () (→* ((∪ Symbol String) Integer) () (Pair Boolean Integer))))
+(: foo2 (∀ () (→* ((∪ Symbol String) Integer) () (Pair Boolean Integer))))
+(: foo3 (∀ () (→* ((∪ Symbol String)) (Integer) (Pair Boolean Integer))))
+(: foo4 (∀ () (→* ((∪ Symbol String)) (Integer) (Pair Boolean Integer))))
+(define foo0 (λ   #:∀ () ([s : (∪ Symbol String)] [i : Integer 0]) : (Pair Boolean Integer) (cons (symbol? s) i)))
+(define foo1 (λ:         ([s : (∪ Symbol String)] [i : Integer])   : (Pair Boolean Integer) (cons (symbol? s) i)))
+(define foo2 (pλ:     () ([s : (∪ Symbol String)] [i : Integer])   : (Pair Boolean Integer) (cons (symbol? s) i)))
+(define foo3 (opt-λ:     ([s : (∪ Symbol String)] [i : Integer 0]) : (Pair Boolean Integer) (cons (symbol? s) i)))
+(define foo4 (popt-λ: () ([s : (∪ Symbol String)] [i : Integer 0]) : (Pair Boolean Integer) (cons (symbol? s) i)))
+(foo0 'abc 0) (foo0 "abc" 0)
+(foo1 'abc 0) (foo1 "abc" 0)
+(foo2 'abc 0) (foo2 "abc" 0)
+(foo3 'abc 0) (foo3 "abc" 0)
+(foo4 'abc 0) (foo4 "abc" 0)
+
+(: bar0 (∀ () (case→ (→ True) (→ Any False))))
+(: bar1 (∀ () (case→ (→ True) (→ Any False))))
+(: bar2 (∀ () (case→ (→ True) (→ Any False))))
+(define bar0 (case-λ  #:∀ () [() #t] [(_) #f]))
+(define bar1 (case-λ: #:∀ () [() #t] [(_) #f]))
+(define bar2 (pcase-λ:    () [() #t] [(_) #f]))
+(bar0) (bar0 bar0)
+(bar1) (bar1 bar1)
+(bar2) (bar2 bar2)