From 0c4f4baf1815bad9aceac7560986a8076c0b068b Mon Sep 17 00:00:00 2001 From: 3ddy Date: Wed, 5 Aug 2020 11:56:59 +0200 Subject: [PATCH 1/2] Add lazy instances where possible --- src/Control/Comonad/Traced/Trans.purs | 3 +++ src/Control/Monad/Cont/Trans.purs | 4 ++++ src/Control/Monad/Except/Trans.purs | 3 +++ src/Control/Monad/List/Trans.purs | 4 ++++ src/Control/Monad/Maybe/Trans.purs | 3 +++ src/Control/Monad/Reader/Trans.purs | 3 +++ src/Control/Monad/Writer/Trans.purs | 3 +++ 7 files changed, 23 insertions(+) diff --git a/src/Control/Comonad/Traced/Trans.purs b/src/Control/Comonad/Traced/Trans.purs index 142cd9b4..86791b00 100644 --- a/src/Control/Comonad/Traced/Trans.purs +++ b/src/Control/Comonad/Traced/Trans.purs @@ -7,6 +7,7 @@ import Prelude import Control.Comonad (class Comonad, extract) import Control.Comonad.Trans.Class (class ComonadTrans) import Control.Extend (class Extend, (<<=)) +import Control.Lazy (class Lazy) import Data.Newtype (class Newtype) -- | The cowriter comonad transformer. @@ -34,3 +35,5 @@ instance comonadTracedT :: (Comonad w, Monoid t) => Comonad (TracedT t w) where instance comonadTransTracedT :: Monoid t => ComonadTrans (TracedT t) where lower (TracedT w) = (\f -> f mempty) <$> w + +derive newtype instance lazyTracedT :: Lazy (w (t -> a)) => Lazy (TracedT t w a) diff --git a/src/Control/Monad/Cont/Trans.purs b/src/Control/Monad/Cont/Trans.purs index 608a77ff..09e7732b 100644 --- a/src/Control/Monad/Cont/Trans.purs +++ b/src/Control/Monad/Cont/Trans.purs @@ -8,6 +8,7 @@ module Control.Monad.Cont.Trans import Prelude +import Control.Lazy (class Lazy) import Control.Monad.Cont.Class (class MonadCont, callCC) import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local) import Control.Monad.State.Class (class MonadState, state) @@ -54,6 +55,9 @@ instance monadContT :: Monad m => Monad (ContT r m) instance monadTransContT :: MonadTrans (ContT r) where lift m = ContT (\k -> m >>= k) +instance lazyContT :: Lazy (ContT r m a) where + defer f = ContT \k -> case f unit of ContT f' -> f' k + instance monadEffectContT :: MonadEffect m => MonadEffect (ContT r m) where liftEffect = lift <<< liftEffect diff --git a/src/Control/Monad/Except/Trans.purs b/src/Control/Monad/Except/Trans.purs index 21ef0148..e7e13a57 100644 --- a/src/Control/Monad/Except/Trans.purs +++ b/src/Control/Monad/Except/Trans.purs @@ -10,6 +10,7 @@ import Prelude import Control.Alt (class Alt) import Control.Alternative (class Alternative) +import Control.Lazy (class Lazy) import Control.Monad.Cont.Class (class MonadCont, callCC) import Control.Monad.Error.Class (class MonadThrow, class MonadError, throwError, catchError) import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local) @@ -101,6 +102,8 @@ instance monadTransExceptT :: MonadTrans (ExceptT e) where a <- m pure $ Right a +derive newtype instance lazyExceptT :: Lazy (m (Either e a)) => Lazy (ExceptT e m a) + instance monadEffectExceptT :: MonadEffect m => MonadEffect (ExceptT e m) where liftEffect = lift <<< liftEffect diff --git a/src/Control/Monad/List/Trans.purs b/src/Control/Monad/List/Trans.purs index aad5bd7d..a174eb8d 100644 --- a/src/Control/Monad/List/Trans.purs +++ b/src/Control/Monad/List/Trans.purs @@ -40,6 +40,7 @@ import Prelude import Control.Alt (class Alt) import Control.Alternative (class Alternative) +import Control.Lazy (class Lazy) import Control.Monad.Rec.Class as MR import Control.Monad.Trans.Class (class MonadTrans, lift) import Control.MonadPlus (class MonadPlus) @@ -314,6 +315,9 @@ instance monadListT :: Monad f => Monad (ListT f) instance monadTransListT :: MonadTrans ListT where lift = fromEffect +instance lazyListT :: Applicative f => Lazy (ListT f a) where + defer f = ListT <<< pure $ Skip (defer f) + instance altListT :: Applicative f => Alt (ListT f) where alt = concat diff --git a/src/Control/Monad/Maybe/Trans.purs b/src/Control/Monad/Maybe/Trans.purs index 625aed0a..65fe84e4 100644 --- a/src/Control/Monad/Maybe/Trans.purs +++ b/src/Control/Monad/Maybe/Trans.purs @@ -9,6 +9,7 @@ import Prelude import Control.Alt (class Alt) import Control.Alternative (class Alternative) +import Control.Lazy (class Lazy) import Control.Monad.Cont.Class (class MonadCont, callCC) import Control.Monad.Error.Class (class MonadThrow, class MonadError, catchError, throwError) import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local) @@ -60,6 +61,8 @@ instance monadMaybeT :: Monad m => Monad (MaybeT m) instance monadTransMaybeT :: MonadTrans MaybeT where lift = MaybeT <<< liftM1 Just +derive newtype instance lazyMaybeT :: Lazy (m (Maybe a)) => Lazy (MaybeT m a) + instance altMaybeT :: Monad m => Alt (MaybeT m) where alt (MaybeT m1) (MaybeT m2) = MaybeT do m <- m1 diff --git a/src/Control/Monad/Reader/Trans.purs b/src/Control/Monad/Reader/Trans.purs index 66fd6b3e..2a3b6b9a 100644 --- a/src/Control/Monad/Reader/Trans.purs +++ b/src/Control/Monad/Reader/Trans.purs @@ -11,6 +11,7 @@ import Prelude import Control.Alt (class Alt, (<|>)) import Control.Alternative (class Alternative) import Control.Apply (lift2) +import Control.Lazy (class Lazy) import Control.Monad.Cont.Class (class MonadCont, callCC) import Control.Monad.Error.Class (class MonadThrow, class MonadError, catchError, throwError) import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, asks, local) @@ -83,6 +84,8 @@ instance monadPlusReaderT :: MonadPlus m => MonadPlus (ReaderT r m) instance monadTransReaderT :: MonadTrans (ReaderT r) where lift = ReaderT <<< const +derive newtype instance lazyReaderT :: Lazy (ReaderT r m a) + instance monadEffectReader :: MonadEffect m => MonadEffect (ReaderT r m) where liftEffect = lift <<< liftEffect diff --git a/src/Control/Monad/Writer/Trans.purs b/src/Control/Monad/Writer/Trans.purs index 862fa01f..bcb3f338 100644 --- a/src/Control/Monad/Writer/Trans.purs +++ b/src/Control/Monad/Writer/Trans.purs @@ -10,6 +10,7 @@ import Prelude import Control.Alt (class Alt, (<|>)) import Control.Alternative (class Alternative) +import Control.Lazy (class Lazy) import Control.Monad.Cont.Class (class MonadCont, callCC) import Control.Monad.Error.Class (class MonadThrow, class MonadError, catchError, throwError) import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local) @@ -93,6 +94,8 @@ instance monadTransWriterT :: Monoid w => MonadTrans (WriterT w) where a <- m pure $ Tuple a mempty +derive newtype instance lazyWriterT :: Lazy (m (Tuple a w)) => Lazy (WriterT w m a) + instance monadEffectWriter :: (Monoid w, MonadEffect m) => MonadEffect (WriterT w m) where liftEffect = lift <<< liftEffect From dbf9beabe6fd104fe96c8b320130e79c991b8475 Mon Sep 17 00:00:00 2001 From: 3ddy Date: Wed, 5 Aug 2020 15:50:20 +0200 Subject: [PATCH 2/2] remaining Lazy instances --- src/Control/Comonad/Env/Trans.purs | 6 ++++-- src/Control/Comonad/Store/Trans.purs | 6 ++++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/Control/Comonad/Env/Trans.purs b/src/Control/Comonad/Env/Trans.purs index e4040464..6e5e8a16 100644 --- a/src/Control/Comonad/Env/Trans.purs +++ b/src/Control/Comonad/Env/Trans.purs @@ -7,10 +7,10 @@ import Prelude import Control.Comonad (class Comonad, extract) import Control.Comonad.Trans.Class (class ComonadTrans) import Control.Extend (class Extend, (<<=)) - +import Control.Lazy (class Lazy) +import Data.Newtype (class Newtype) import Data.Traversable (class Traversable, class Foldable, foldl, foldr, foldMap, traverse, sequence) import Data.Tuple (Tuple(..)) -import Data.Newtype (class Newtype) -- | The environment comonad transformer. -- | @@ -46,6 +46,8 @@ instance comonadEnvT :: Comonad w => Comonad (EnvT e w) where instance comonadTransEnvT :: ComonadTrans (EnvT e) where lower (EnvT (Tuple e x)) = x +derive newtype instance lazyEnvT :: (Lazy e, Lazy (w a)) => Lazy (EnvT e w a) + instance foldableEnvT :: Foldable f => Foldable (EnvT e f) where foldl fn a (EnvT (Tuple _ x)) = foldl fn a x foldr fn a (EnvT (Tuple _ x)) = foldr fn a x diff --git a/src/Control/Comonad/Store/Trans.purs b/src/Control/Comonad/Store/Trans.purs index 3c393555..9fcafda5 100644 --- a/src/Control/Comonad/Store/Trans.purs +++ b/src/Control/Comonad/Store/Trans.purs @@ -7,9 +7,9 @@ import Prelude import Control.Comonad (class Comonad, extract) import Control.Comonad.Trans.Class (class ComonadTrans) import Control.Extend (class Extend, (<<=)) - -import Data.Tuple (Tuple(..)) +import Control.Lazy (class Lazy) import Data.Newtype (class Newtype) +import Data.Tuple (Tuple(..)) -- | The store comonad transformer. -- | @@ -36,3 +36,5 @@ instance comonadStoreT :: Comonad w => Comonad (StoreT s w) where instance comonadTransStoreT :: ComonadTrans (StoreT s) where lower (StoreT (Tuple w s)) = (_ $ s) <$> w + +derive newtype instance lazyStoreT :: (Lazy (w (s -> a)), Lazy s) => Lazy (StoreT s w a)