Use unit

Author: garyb

README.md

@@ -63,7 +63,7 @@
 
     class Error a where
       noMsg :: a
-      strMsg :: Prim.String -> a
+      strMsg :: String -> a
 
 
 ### Type Class Instances
@@ -142,7 +142,7 @@
     data Free f a where
       Pure :: a -> Free f a
       Free :: f (Free f a) -> Free f a
-      Gosub :: forall s. (forall r. ({  } -> Free f r) -> (r -> Free f a) -> s) -> s -> Free f a
+      Gosub :: forall s. (forall r. (Unit -> Free f r) -> (r -> Free f a) -> s) -> s -> Free f a
 
 
 ### Type Classes
@@ -184,7 +184,7 @@
 
     resume :: forall f a. (Functor f) => Free f a -> Either (f (Free f a)) a
 
-    resumeGosub :: forall f a. (Functor f) => (forall s. (forall r. ({  } -> Free f r) -> (r -> Free f a) -> s) -> s) -> Either (f (Free f a)) (Free f a)
+    resumeGosub :: forall f a. (Functor f) => (forall s. (forall r. (Unit -> Free f r) -> (r -> Free f a) -> s) -> s) -> Either (f (Free f a)) (Free f a)
 
 
 ## Module Control.Monad.Identity
@@ -385,9 +385,9 @@
 
     gets :: forall s m a. (Monad m, MonadState s m) => (s -> a) -> m a
 
-    modify :: forall s m. (Monad m, MonadState s m) => (s -> s) -> m {  }
+    modify :: forall s m. (Monad m, MonadState s m) => (s -> s) -> m Unit
 
-    put :: forall m s. (Monad m, MonadState s m) => s -> m {  }
+    put :: forall m s. (Monad m, MonadState s m) => s -> m Unit
 
 
 ## Module Control.Monad.State.Trans
@@ -443,7 +443,7 @@
 ### Types
 
     data Delay a where
-      Delay :: {  } -> a -> Delay a
+      Delay :: Unit -> a -> Delay a
 
     type Trampoline a = Free Delay a
 
@@ -459,7 +459,7 @@
 
 ### Values
 
-    delay :: forall a. ({  } -> a) -> Trampoline a
+    delay :: forall a. (Unit -> a) -> Trampoline a
 
     done :: forall a. a -> Trampoline a
 
@@ -521,7 +521,7 @@
 
     listens :: forall w m a b. (Monoid w, Monad m, MonadWriter w m) => (w -> b) -> m a -> m (Tuple a b)
 
-    tell :: forall w m a. (Monoid w, Monad m, MonadWriter w m) => w -> m {  }
+    tell :: forall w m a. (Monoid w, Monad m, MonadWriter w m) => w -> m Unit
 
 
 ## Module Control.Monad.Writer.Trans

src/Control/Monad/Free.purs

@@ -6,7 +6,7 @@ import Data.Either
 
 data Free f a = Pure a
               | Free (f (Free f a))
-              | Gosub (forall s. (forall r. ({} -> Free f r) -> (r -> Free f a) -> s) -> s)
+              | Gosub (forall s. (forall r. (Unit -> Free f r) -> (r -> Free f a) -> s) -> s)
 
 class MonadFree f m where
   wrap :: forall a. f (m a) -> m a
@@ -45,20 +45,20 @@ pureF a = Free (pure (Pure  a))
 iterM :: forall f m a. (Functor f, Monad m) => (forall a. f (m a) -> m a) -> Free f a -> m a
 iterM _ (Pure a) = return a
 iterM k (Free f) = k $ iterM k <$> f
-iterM k (Gosub f) = f (\req recv -> iterM k (req {}) >>= (iterM k <<< recv))
+iterM k (Gosub f) = f (\req recv -> iterM k (req unit) >>= (iterM k <<< recv))
 
 -- Note: can blow the stack!
 goM :: forall f m a. (Functor f, Monad m) => (f (Free f a) -> m (Free f a)) -> Free f a -> m a
 goM k f = case resume f of
             Left s -> k s >>= goM k
             Right a -> return a
 
-resumeGosub :: forall f a. (Functor f) => (forall s. (forall r. ({} -> Free f r) -> (r -> Free f a) -> s) -> s) -> Either (f (Free f a)) (Free f a)
+resumeGosub :: forall f a. (Functor f) => (forall s. (forall r. (Unit -> Free f r) -> (r -> Free f a) -> s) -> s) -> Either (f (Free f a)) (Free f a)
 resumeGosub f = f (\a g ->
-  case a {} of
+  case a unit of
     Pure a -> Right (g a)
     Free t -> Left ((\h -> h >>= g) <$> t)
-    Gosub h -> Right (h (\b i -> b {} >>= (\x -> i x >>= g)))
+    Gosub h -> Right (h (\b i -> b unit >>= (\x -> i x >>= g)))
   )
 
 foreign import resume

src/Control/Monad/State/Class.purs

@@ -20,11 +20,11 @@ get = state \s -> Tuple s s
 gets :: forall s m a. (Monad m, MonadState s m) => (s -> a) -> m a
 gets f = state \s -> Tuple (f s) s
 
-put :: forall m s. (Monad m, MonadState s m) => s -> m {}
-put s = state \_ -> Tuple {} s
+put :: forall m s. (Monad m, MonadState s m) => s -> m Unit
+put s = state \_ -> Tuple unit s
 
-modify :: forall s m. (Monad m, MonadState s m) => (s -> s) -> m {}
-modify f = state \s -> Tuple {} (f s)
+modify :: forall s m. (Monad m, MonadState s m) => (s -> s) -> m Unit
+modify f = state \s -> Tuple unit (f s)
 
 instance monadStateStateT :: (Monad m) => MonadState s (StateT s m) where
   state f = StateT $ return <<< f

src/Control/Monad/Trampoline.purs

@@ -2,27 +2,27 @@ module Control.Monad.Trampoline where
 
 import Control.Monad.Free
 
-data Delay a = Delay ({} -> a)
+data Delay a = Delay (Unit -> a)
 
 instance delayFunctor :: Functor Delay where
-  (<$>) f (Delay g) = Delay (const (f (g {})))
+  (<$>) f (Delay g) = Delay (const (f (g unit)))
 
 instance delayApply :: Apply Delay where
-  (<*>) (Delay f) (Delay a) = Delay (\{} -> (f {}) (a {}))
+  (<*>) (Delay f) (Delay a) = Delay (\_ -> (f unit) (a unit))
 
 instance delayApplicative :: Applicative Delay where
-  pure a = Delay (\{} -> a)
+  pure a = Delay (const a)
 
 type Trampoline a = Free Delay a
 
 done :: forall a. a -> Trampoline a
 done = Pure
 
 suspend :: forall a. Trampoline a -> Trampoline a
-suspend a = Free (Delay (\{} -> a))
+suspend a = Free (Delay (const a))
 
-delay :: forall a. ({} -> a) -> Trampoline a
+delay :: forall a. (Unit -> a) -> Trampoline a
 delay a = Free (done <$> Delay a)
 
 runTrampoline :: forall a. Trampoline a -> a
-runTrampoline = go (\(Delay f) -> f {})
+runTrampoline = go (\(Delay f) -> f unit)

src/Control/Monad/Writer/Class.purs

@@ -16,8 +16,8 @@ class MonadWriter w m where
   listen :: forall a. m a -> m (Tuple a w)
   pass :: forall a. m (Tuple a (w -> w)) -> m a
 
-tell :: forall w m a. (Monoid w, Monad m, MonadWriter w m) => w -> m {}
-tell w = writer $ Tuple {} w
+tell :: forall w m a. (Monoid w, Monad m, MonadWriter w m) => w -> m Unit
+tell w = writer $ Tuple unit w
 
 listens :: forall w m a b. (Monoid w, Monad m, MonadWriter w m) => (w -> b) -> m a -> m (Tuple a b)
 listens f m = do