Do some more module reorganization to inline Eq, Show, Semigroup, Monoid

Author: lexi-lambda

hackett-demo/hackett/demo/web-server.rkt

@@ -25,8 +25,8 @@
 (module untyped racket/base
   (require (prefix-in hackett: (combine-in hackett (submod ".." shared)))
            (only-in hackett : -> Integer String IO Unit)
-           (only-in hackett/private/prim [type-#%app #%app] typed-out)
-           (only-in hackett/private/prim/io io)
+           hackett/private/prim/type-provide
+           (only-in hackett/private/prim/type io)
            racket/string
            racket/promise
            net/url-structs

hackett-lib/hackett/data/list.rkt

@@ -5,7 +5,7 @@
          hackett/private/prim
          hackett/private/provide)
 
-(provide (data List) head tail head! tail! zip-with)
+(provide (data List) head tail head! tail! take zip-with)
 
 (defn head : (∀ [a] {(List a) -> (Maybe a)})
   [[{x :: _}] (just x)]
@@ -21,13 +21,14 @@
 (defn tail! : (∀ [a] {(List a) -> (List a)})
   [[xs] (from-maybe (error! "tail!: empty list") (tail xs))])
 
+(defn take : (∀ [a] {Integer -> (List a) -> (List a)})
+  [[n {x :: xs}]
+   (if {n == 0}
+       nil
+       {x :: (take {n - 1} xs)})]
+  [[_ nil]
+   nil])
+
 (defn zip-with : (∀ [a b c] {{a -> b -> c} -> (List a) -> (List b) -> (List c)})
   [[f {x :: xs} {y :: ys}] {(f x y) :: (zip-with f xs ys)}]
   [[_ _         _        ] nil])
-
-(defn sequence : (∀ [f a] (Applicative f) => {(List (f a)) -> (f (List a))})
-  [[{y :: ys}] {:: <$> y <*> (sequence ys)}]
-  [[nil      ] (pure nil)])
-
-(defn traverse : (∀ [f a b] (Applicative f) => {{a -> (f b)} -> (List a) -> (f (List b))})
-  [[f xs] (sequence (map f xs))])

hackett-lib/hackett/monoid.rkt

@@ -7,22 +7,20 @@
 
          hackett/data/list
          hackett/data/maybe
-         hackett/monoid
-         hackett/semigroup
 
          hackett/private/prim
          hackett/private/provide)
 
 (provide (all-from-out hackett/data/list)
          (all-from-out hackett/data/maybe)
-         (all-from-out hackett/monoid)
-         (all-from-out hackett/semigroup)
 
          (data Unit) (data Bool) (data Tuple) (data Maybe) (data List)
          not or and if fst snd
 
          id compose const flip
 
+         (class Eq) (class Show) (class Semigroup) (class Monoid)
+
          (class Functor) (rename-out [map <$>]) <&> <$ $> ignore
          (class Applicative) sequence traverse
          (class Monad) =<< >>= do ap
@@ -43,60 +41,3 @@
 (defn println : {String -> (IO Unit)}
   [[str] (do (print str)
              (print "\n"))])
-
-;; ---------------------------------------------------------------------------------------------------
-;; Show
-
-(class (Show a)
-  [show : {a -> String}])
-
-(instance (Show Unit)
-  [show (λ [unit] "unit")])
-
-(instance (Show Bool)
-  [show (λ* [[true ] "true"]
-            [[false] "false"])])
-
-(instance (Show Integer)
-  [show show/Integer])
-
-(instance (Show String)
-  [show (λ [str] {"\"" ++ str ++ "\""})])
-
-(instance (∀ [a] (Show a) => (Show (Maybe a)))
-  [show (λ* [[(just x)] {"(just " ++ (show x) ++ ")"}]
-            [[nothing ] "nothing"])])
-
-(instance (∀ [a b] (Show a) (Show b) => (Show (Tuple a b)))
-  [show (λ [(tuple a b)] {"(tuple " ++ (show a) ++ " " ++ (show b) ++ ")"})])
-
-(instance (∀ [a] (Show a) => (Show (List a)))
-  [show (λ* [[{y :: ys}] {"{" ++ (show y) ++ " :: " ++ (show ys) ++ "}"}]
-            [[nil      ] "nil"])])
-
-;; ---------------------------------------------------------------------------------------------------
-;; Eq
-
-(class (Eq a)
-  [== : {a -> a -> Bool}])
-
-(instance (Eq Unit)
-  [== (λ [unit unit] true)])
-
-(instance (Eq Bool)
-  [== (λ* [[true  y] y]
-          [[false y] (not y)])])
-
-(instance (Eq Integer)
-  [== equal?/Integer])
-
-(instance (Eq String)
-  [== equal?/String])
-
-(instance (∀ [a] (Eq a) => (Eq (Maybe a)))
-  [== (λ* [[(just a) (just b)] (== a b)]
-          [[nothing  nothing ] true]
-          [[_        _       ] false])])
-
-(instance (∀ [a b] (Eq a) (Eq b) => (Eq (Tuple a b)))
-  [== (λ [(tuple a b) (tuple c d)] (and (== a c) (== b d)))])

hackett-lib/hackett/prelude.rkt

@@ -1,9 +1,24 @@
 #lang racket/base
 
-(require hackett/private/prim/base
-         hackett/private/prim/io
-         hackett/private/prim/op)
+(require hackett/private/util/require
+
+         (for-syntax racket/base)
+         (postfix-in - (combine-in racket/base racket/promise))
+         syntax/parse/define
+         (only-in hackett/private/base with-dictionary-elaboration)
+         (only-in hackett/private/kernel [#%app @%app])
+
+         hackett/private/prim/base
+         hackett/private/prim/op
+         hackett/private/prim/type)
 
 (provide (all-from-out hackett/private/prim/base)
-         (all-from-out hackett/private/prim/io)
-         (all-from-out hackett/private/prim/op))
+         (all-from-out hackett/private/prim/op)
+         (all-from-out hackett/private/prim/type)
+
+         main)
+
+(define-syntax-parser main
+  [(_ e:expr)
+   #'(module+ main
+       (void- (with-dictionary-elaboration (force- (@%app unsafe-run-io! e)))))])

hackett-lib/hackett/private/prim.rkt

@@ -8,27 +8,23 @@
          (except-in hackett/private/adt data)
          (except-in hackett/private/class class)
          hackett/private/provide
+         hackett/private/prim/op
+         hackett/private/prim/type
          syntax/parse/define)
 
-(provide (data Unit) (data Bool) (data Tuple) (data Maybe) (data List)
-         not or and if fst snd
+(provide not or and if fst snd unsafe-run-io!
 
          id compose const flip
 
+         (class Eq) (class Show)
+         (class Semigroup) (class Monoid)
+
          (class Functor) (rename-out [map <$>]) <&> <$ $> ignore
          (class Applicative) sequence traverse
          (class Monad) =<< >>= do ap)
 
 ;; ---------------------------------------------------------------------------------------------------
-;; datatypes
-
-(data Unit unit)
-(data Bool true false)
-(data (Tuple a b) (tuple a b))
-(data (Maybe a) (just a) nothing)
-(data (List a)
-  {a :: (List a)} #:fixity right
-  nil)
+;; basic operations
 
 (defn not : {Bool -> Bool}
   [[true ] false]
@@ -52,6 +48,9 @@
 (defn snd : (∀ [a b] {(Tuple a b) -> b})
   [[(tuple _ x)] x])
 
+(defn unsafe-run-io! : (∀ [a] {(IO a) -> a})
+  [[(io f)] (snd (f real-world))])
+
 ;; ---------------------------------------------------------------------------------------------------
 ;; function combinators
 
@@ -67,6 +66,86 @@
 (defn flip : (∀ [a b c] {{a -> b -> c} -> b -> a -> c})
   [[f x y] (f y x)])
 
+;; ---------------------------------------------------------------------------------------------------
+;; Show
+
+(class (Show a)
+  [show : {a -> String}])
+
+(instance (Show Unit)
+  [show (λ [unit] "unit")])
+
+(instance (Show Bool)
+  [show (λ* [[true ] "true"]
+            [[false] "false"])])
+
+(instance (Show Integer)
+  [show show/Integer])
+
+(instance (Show String)
+  [show (λ [str] {"\"" ++ str ++ "\""})])
+
+(instance (∀ [a] (Show a) => (Show (Maybe a)))
+  [show (λ* [[(just x)] {"(just " ++ (show x) ++ ")"}]
+            [[nothing ] "nothing"])])
+
+(instance (∀ [a b] (Show a) (Show b) => (Show (Tuple a b)))
+  [show (λ [(tuple a b)] {"(tuple " ++ (show a) ++ " " ++ (show b) ++ ")"})])
+
+(instance (∀ [a] (Show a) => (Show (List a)))
+  [show (λ* [[{y :: ys}] {"{" ++ (show y) ++ " :: " ++ (show ys) ++ "}"}]
+            [[nil      ] "nil"])])
+
+;; ---------------------------------------------------------------------------------------------------
+;; Eq
+
+(class (Eq a)
+  [== : {a -> a -> Bool}])
+
+(instance (Eq Unit)
+  [== (λ [unit unit] true)])
+
+(instance (Eq Bool)
+  [== (λ* [[true  y] y]
+          [[false y] (not y)])])
+
+(instance (Eq Integer)
+  [== equal?/Integer])
+
+(instance (Eq String)
+  [== equal?/String])
+
+(instance (∀ [a] (Eq a) => (Eq (Maybe a)))
+  [== (λ* [[(just a) (just b)] (== a b)]
+          [[nothing  nothing ] true]
+          [[_        _       ] false])])
+
+(instance (∀ [a b] (Eq a) (Eq b) => (Eq (Tuple a b)))
+  [== (λ [(tuple a b) (tuple c d)] (and (== a c) (== b d)))])
+
+;; ---------------------------------------------------------------------------------------------------
+;; Semigroup / Monoid
+
+(class (Semigroup a)
+  [++ : {a -> a -> a}
+      #:fixity right])
+
+(instance (Semigroup String)
+  [++ append/String])
+
+(instance (∀ [a] (Semigroup (List a)))
+  [++ (λ* [[{z :: zs} ys] {z :: {zs ++ ys}}]
+          [[nil       ys] ys])])
+
+(class (Semigroup a) => (Monoid a)
+  [mempty : a])
+
+(instance (Monoid String)
+  [mempty ""])
+
+(instance (∀ [a] (Monoid (List a)))
+  [mempty nil])
+
 ;; ---------------------------------------------------------------------------------------------------
 ;; Functor
 
@@ -93,6 +172,12 @@
   [map (λ* [[f {y :: ys}] {(f y) :: (map f ys)}]
            [[_ nil      ] nil])])
 
+(instance (Functor IO)
+  [map (λ [f (io mx)]
+         (io (λ [rw]
+               (case (mx rw)
+                 [(tuple rw* a) (tuple rw* (f a))]))))])
+
 ;; ---------------------------------------------------------------------------------------------------
 ;; Applicative
 
@@ -116,6 +201,10 @@
   [pure (λ [x] {x :: nil})]
   [<*> ap])
 
+(instance (Applicative IO)
+  [pure (λ [x] (io (λ [rw] (tuple rw x))))]
+  [<*> ap])
+
 ;; ---------------------------------------------------------------------------------------------------
 ;; Monad
 
@@ -152,3 +241,12 @@
   [join (λ* [[{{z :: zs} :: yss}] {z :: (join {zs :: yss})}]
             [[{nil       :: yss}] (join yss)]
             [[nil               ] nil])])
+
+(instance (Monad IO)
+  [join (λ [(io outer)]
+          (io (λ [rw]
+                (case (outer rw)
+                  [(tuple rw* m-inner)
+                   (case m-inner
+                     [(io inner)
+                      (inner rw*)])]))))])