adt: add integer patterns

Author: bennn

hackett-lib/hackett/private/adt.rkt

@@ -200,6 +200,7 @@
   (struct pat-hole pat-base () #:transparent)
   (struct pat-con pat-base (constructor pats) #:transparent)
   (struct pat-str pat-base (str) #:transparent)
+  (struct pat-int pat-base (int) #:transparent)
   (define pat? pat-base?)
 
   (define-syntax-class pat
@@ -266,6 +267,9 @@
              #:attr disappeared-uses '()]
     [pattern str:str
              #:attr pat (pat-str this-syntax #'str)
+             #:attr disappeared-uses '()]
+    [pattern int:integer
+             #:attr pat (pat-int this-syntax #'int)
              #:attr disappeared-uses '()])
 
   (define/contract (pat⇒! pat)
@@ -284,7 +288,9 @@
        (let ([a^ (generate-temporary)])
          (values #`(#%type:wobbly-var #,a^) '() #{values #'_ %}))]
       [(pat-str _ str)
-       (values (expand-type #'String) '() #{values str %})]
+       (values (expand-type #'String) '() #{values #`(app force- #,str) %})]
+      [(pat-int _ int)
+       (values (expand-type #'Integer) '() #{values #`(app force- #,int) %})]
       [(pat-con _ con pats)
        (let*-values ([(τs_args τ_result) (data-constructor-args/result! con)]
                      [(assumps mk-pats) (pats⇐! pats τs_args)])
@@ -431,7 +437,8 @@
 
         ; TODO: better exhaustiveness checking on strings. OCaml checks for the strings "*", "**",
         ; "***" etc. It would be fairly easy to do the same using splitting.
-        [(pat-str _ s) #f])))
+        [(pat-str _ s) #f]
+        [(pat-int _ i) #f])))
 
 
   ; Checks if patterns are exhaustive or not. Given a list of pattern-lists, returns #f if no

hackett-test/tests/hackett/integration/int-pattern.rkt

@@ -0,0 +1,36 @@
+#lang hackett
+
+(require hackett/private/test)
+
+(defn small-int? : {Integer -> Bool}
+  [[0] True]
+  [[1] True]
+  [[2] True]
+  [[_] False])
+
+(test {(small-int? 0) ==! True})
+(test {(small-int? 2) ==! True})
+(test {(small-int? 4) ==! False})
+
+(defn zero-or-none? : {(Maybe Integer) -> Bool}
+  [[Nothing] True]
+  [[(Just 0)] True]
+  [[_] False])
+
+(test {(zero-or-none? Nothing) ==! True})
+(test {(zero-or-none? (Just 0)) ==! True})
+(test {(zero-or-none? (Just 2)) ==! False})
+
+(defn special-list? : {(List Integer) -> Bool}
+  [[(:: 2 (:: n Nil))] {2 == n}]
+  [[_] False])
+
+(test {(special-list? (:: 2 (:: 2 Nil))) ==! True})
+(test {(special-list? (:: 2 (:: 3 Nil))) ==! False})
+(test {(special-list? (:: 3 (:: 2 Nil))) ==! False})
+
+(defn fact : {Integer -> Integer}
+  [[0] 1]
+  [[n] (* n (fact (- n 1)))])
+
+(test {(fact 2) ==! 2})

hackett-test/tests/hackett/integration/str-pattern.rkt

@@ -0,0 +1,13 @@
+#lang hackett
+
+(require hackett/private/test)
+
+;; The purpose of `countA` is to be a recursive function that makes enough
+;;  recursive calls to "run forever" if string patterns aren't forced
+(defn countA : {String -> Integer}
+  [[""] 0]
+  [["A"] 1]
+  [[other] (+ (countA (head! (string-split "B" other)))
+              (countA (head! (tail! (string-split "B" other)))))])
+
+(test {(countA "ABA") ==! 2})