Use unit

Author: garyb

README.md

@@ -1,5 +1,3 @@
 # Deprecation Notice
 
 Please note that this library has been merged into [purescript-transformers](https://github.com/purescript-contrib/purescript-transformers).
-
-Development will be continued there.

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/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)