From 532dba9e53226ae4508a16c45a97d6f6df37bc2f Mon Sep 17 00:00:00 2001
From: ben <benjaminlgreenman@gmail.com>
Date: Sat, 12 Mar 2016 21:28:10 -0500
Subject: [PATCH] [define] one define/let for all

---
 define.rkt           | 30 ++++++++++++++++++++++++++++++
 define/no-colon.rkt  |  7 +++++++
 main.rkt             | 12 ++++++++++--
 private/db.rkt       |  1 +
 private/function.rkt |  1 +
 private/math.rkt     |  4 +++-
 private/regexp.rkt   | 10 +++++++---
 private/vector.rkt   |  5 ++++-
 test/define-pass.rkt | 24 ++++++++++++++++++++++++
 test/regexp-pass.rkt |  5 +++++
 10 files changed, 92 insertions(+), 7 deletions(-)
 create mode 100644 define.rkt
 create mode 100644 define/no-colon.rkt
 create mode 100644 test/define-pass.rkt

diff --git a/define.rkt b/define.rkt
new file mode 100644
index 0000000..2b74bb3
--- /dev/null
+++ b/define.rkt
@@ -0,0 +1,30 @@
+#lang typed/racket/base
+
+(provide
+  define: let:
+)
+
+(require
+  (for-syntax
+    trivial/private/common
+    racket/base)
+  (only-in trivial/private/math
+    num-define
+    num-let)
+  (only-in trivial/private/regexp
+    rx-define
+    rx-let)
+  (only-in trivial/private/vector
+    vec-define
+    vec-let))
+
+(define-syntax define: (make-keyword-alias 'define
+  (lambda (stx)
+    (or (num-define stx)
+        (rx-define stx)
+        (vec-define stx)))))
+(define-syntax let: (make-keyword-alias 'let
+  (lambda (stx)
+    (or (num-let stx)
+        (rx-let stx)
+        (vec-let stx)))))
diff --git a/define/no-colon.rkt b/define/no-colon.rkt
new file mode 100644
index 0000000..7626f6e
--- /dev/null
+++ b/define/no-colon.rkt
@@ -0,0 +1,7 @@
+#lang typed/racket/base
+
+(provide (rename-out
+  [define: define]
+  [let: let]))
+
+(require trivial/define)
diff --git a/main.rkt b/main.rkt
index 1817d1d..51de75b 100644
--- a/main.rkt
+++ b/main.rkt
@@ -1,11 +1,19 @@
 #lang typed/racket/base
 
 (provide
+  (all-from-out trivial/define)
   (all-from-out trivial/format)
+  (all-from-out trivial/function)
   (all-from-out trivial/math)
-  (all-from-out trivial/regexp))
+  (all-from-out trivial/regexp)
+  (all-from-out trivial/vector))
 
 (require
+  ;trivial/db
+  trivial/define
   trivial/format
+  trivial/function
   trivial/math
-  trivial/regexp)
+  trivial/regexp
+  trivial/vector)
+
diff --git a/private/db.rkt b/private/db.rkt
index 8575142..43a0d9f 100644
--- a/private/db.rkt
+++ b/private/db.rkt
@@ -1,6 +1,7 @@
 #lang typed/racket/base
 
 ;; TODO do not use this library, it's just for demonstration
+;; TODO confusing row/column
 
 (provide
   start-transaction
diff --git a/private/function.rkt b/private/function.rkt
index 206149a..8de10ec 100644
--- a/private/function.rkt
+++ b/private/function.rkt
@@ -5,6 +5,7 @@
 ;; - 
 ;; - vectorized ops
 ;; - (TODO) improve apply/map? ask Leif
+;; - TODO get types, not arity
 
 (provide
   curry:
diff --git a/private/math.rkt b/private/math.rkt
index 8be4d1a..47cafe1 100644
--- a/private/math.rkt
+++ b/private/math.rkt
@@ -17,7 +17,9 @@
     stx->num
     nat/expand
     int/expand
-    num/expand)
+    num/expand
+    num-define
+    num-let)
 )
 
 (require (for-syntax
diff --git a/private/regexp.rkt b/private/regexp.rkt
index 9185666..22b2afc 100644
--- a/private/regexp.rkt
+++ b/private/regexp.rkt
@@ -11,6 +11,10 @@
   let-regexp:
 
   regexp-match:
+
+  (for-syntax
+    rx-define
+    rx-let)
 )
 
 (require
@@ -104,7 +108,7 @@
   (define parse-groups/byte-pregexp
     parse-groups/byte-regexp)
 
-  (define-values (num-groups-key rx? def-rx let-rx)
+  (define-values (num-groups-key rx? rx-define rx-let)
     (make-value-property 'rx:groups parse-groups))
   (define-syntax-class/predicate pattern/groups rx?)
 )
@@ -128,8 +132,8 @@
 
 (define-matcher* regexp pregexp byte-regexp byte-pregexp)
 
-(define-syntax define-regexp: (make-keyword-alias 'define def-rx))
-(define-syntax let-regexp: (make-keyword-alias 'let let-rx))
+(define-syntax define-regexp: (make-keyword-alias 'define rx-define))
+(define-syntax let-regexp: (make-keyword-alias 'let rx-let))
 
 (define-syntax regexp-match: (make-alias #'regexp-match
   (lambda (stx) (syntax-parse stx
diff --git a/private/vector.rkt b/private/vector.rkt
index 57b8550..ff32a1a 100644
--- a/private/vector.rkt
+++ b/private/vector.rkt
@@ -21,6 +21,8 @@
 
   ;; --- private
   (for-syntax
+    vec-define
+    vec-let
     parse-vector-length
     vector-length-key)
 )
@@ -58,6 +60,7 @@
            #(e* ...)
            ;; TODO #{} #[] #6{} ...
            (#%plain-app vector e* ...)
+           (#%plain-app vector e* ...)
            (vector e* ...))
       (length (syntax-e #'(e* ...)))]
      [(~or (make-vector n e* ...)
@@ -80,7 +83,7 @@
 (define-syntax let-vector: (make-keyword-alias 'let vec-let))
 
 (define-syntax vector-length: (make-alias #'vector-length
-  (lambda (stx) (syntax-parse stx
+  (lambda (stx) (printf "hehhl ~a\n" (syntax->datum stx)) (syntax-parse stx
    [(_ v:vector/length)
     (syntax/loc stx 'v.evidence)]
    [_ #f]))))
diff --git a/test/define-pass.rkt b/test/define-pass.rkt
new file mode 100644
index 0000000..95b60c0
--- /dev/null
+++ b/test/define-pass.rkt
@@ -0,0 +1,24 @@
+#lang typed/racket/base
+(require trivial/define trivial/math trivial/regexp trivial/vector)
+
+(module+ test
+  (require typed/rackunit)
+
+  (check-equal?
+    (let ()
+      (define: n 3)
+      (let: ([m n])
+        (ann (-: n m) Zero)))
+    0)
+
+  (check-equal?
+    (let: ([x (regexp: "(a*)(b*)")])
+      (let ([m (regexp-match: x "aaabbb")])
+        (if m (string-append (cadr m) (caddr m)) "")))
+    "aaabbb")
+
+  (check-equal?
+    (let: ([v '#(3 9 2)])
+      (ann (-: (vector-length: v) 3) Zero))
+    0)
+)
diff --git a/test/regexp-pass.rkt b/test/regexp-pass.rkt
index 4c1b13c..77bf924 100644
--- a/test/regexp-pass.rkt
+++ b/test/regexp-pass.rkt
@@ -255,6 +255,11 @@
     '(#"hellooo" #"ll" #"ooo"))
 
   ;; -- special cases / miscellaneous
+  (check-equal?
+    (ann
+      (regexp-match: "((a)b)" "ab")
+      (U #f (List String String String)))
+    '("ab" "ab" "a"))
 
   ;; --- Can't handle |, yet
   (check-equal?