Added Typed Racket.

WTF this language actually sucks.
2025-10-07 19:49:43 -04:00
parent 34cee3e910
commit 93e78f6066
8 changed files with 248 additions and 0 deletions
@@ -0,0 +1,66 @@
+;; The first three lines of this file were inserted by DrRacket. They record metadata
+;; about the language level of this file in a form that our tools can easily process.
+#reader(lib "htdp-intermediate-lambda-reader.ss" "lang")((modname main) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #f #t none #f () #f)))
+; foo: bar: (A → A) → (A → A)
+(define (foo bar)
+  (local [(define (baz buzz)
+            (bar (bar buzz)))] baz))
+
+(check-expect ((foo add1) 1) 3)
+
+; goodies: good?: (A → Boolean), l: [A] → [Index]
+; Returns a list of indices considered "good."
+(define (goodies good? l)
+  (local [; goodies/help: l: [A], i: Index, a: [Index] → [Index]
+          (define (goodies/help l i a)
+            (cond [(empty? l) (reverse a)]
+                  [(good? (first l)) (goodies/help (rest l) (add1 i) (cons i a))]
+                  [else (goodies/help (rest l) (add1 i) a)]))]
+    (goodies/help l 0 '())))
+
+(check-expect (goodies even? '(1 2 3 4 5)) '(1 3))
+(check-expect (goodies even? '()) '())
+
+; groupby: key: (A → B), l: [A], same? (B, B → Boolean) → [[A]]
+; This isn't tail-recursive, so it takes up more memory than strictly necessary, but it doesn't need to reverse the list so probably faster.
+(define (groupby key l same?)
+  (if (empty? l) '()
+      (local [(define key1same? (λ (x) (same? (key x) (key (first l)))))]
+        (cons (filter key1same? l) (groupby key (filter (λ (x) (not (key1same? x))) l) same?)))))
+
+(check-expect (groupby even? '(1 2 3 4 5) equal?) '((1 3 5) (2 4)))
+(check-expect (groupby (lambda (x) (modulo x 3)) '(1 2 1 2 54 2 5 43 7 2 643 1 2 0) equal?) '((1 1 43 7 643 1) (2 2 2 5 2 2) (54 0)))
+
+; cart: [[A]] → [[A]]
+; Takes a list of n lists, and computes the n-ary cartesian product.
+(define (cart ll)
+  (foldr (λ (l acc)
+           (foldr append ; Concat all lists.
+                  '()
+                  (map (λ (x) (map (λ (m) (cons x m)) acc)) l))) ; Create list of lists for each x.
+         '(()) ; Base case.
+         ll))
+
+(check-expect (cart '((1 2 3) (a b c)))
+              '((1 a) (1 b) (1 c) (2 a) (2 b) (2 c) (3 a) (3 b) (3 c)))
+(check-expect (cart '((4 5 6) (d e f) (#t #f)))
+              '((4 d #t)
+                (4 d #f)
+                (4 e #t)
+                (4 e #f)
+                (4 f #t)
+                (4 f #f)
+                (5 d #t)
+                (5 d #f)
+                (5 e #t)
+                (5 e #f)
+                (5 f #t)
+                (5 f #f)
+                (6 d #t)
+                (6 d #f)
+                (6 e #t)
+                (6 e #f)
+                (6 f #t)
+                (6 f #f)))
+
+