dunai 0.7.0 → 0.8.0

raw patch · 3 files changed

+1/−20 lines, 3 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Control.Monad.Trans.MSF.Reader: newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type

+ Control.Monad.Trans.MSF.Reader: newtype ReaderT r (m :: Type -> Type) a

- Control.Monad.Trans.MSF.Except: ExceptT :: m (Either e a) -> ExceptT e a

+ Control.Monad.Trans.MSF.Except: ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a

- Control.Monad.Trans.MSF.Except: catchE :: Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a

+ Control.Monad.Trans.MSF.Except: catchE :: forall (m :: Type -> Type) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a

- Control.Monad.Trans.MSF.Except: except :: () => Either e a -> Except e a

+ Control.Monad.Trans.MSF.Except: except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a

- Control.Monad.Trans.MSF.Except: mapExcept :: () => (Either e a -> Either e' b) -> Except e a -> Except e' b

+ Control.Monad.Trans.MSF.Except: mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b

- Control.Monad.Trans.MSF.Except: mapExceptT :: () => (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

+ Control.Monad.Trans.MSF.Except: mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

- Control.Monad.Trans.MSF.Except: runExcept :: () => Except e a -> Either e a

+ Control.Monad.Trans.MSF.Except: runExcept :: Except e a -> Either e a

- Control.Monad.Trans.MSF.Except: runExceptT :: () => ExceptT e m a -> m (Either e a)

+ Control.Monad.Trans.MSF.Except: runExceptT :: ExceptT e m a -> m (Either e a)

- Control.Monad.Trans.MSF.Except: throwE :: Monad m => e -> ExceptT e m a

+ Control.Monad.Trans.MSF.Except: throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a

- Control.Monad.Trans.MSF.Except: withExcept :: () => (e -> e') -> Except e a -> Except e' a

+ Control.Monad.Trans.MSF.Except: withExcept :: (e -> e') -> Except e a -> Except e' a

- Control.Monad.Trans.MSF.Except: withExceptT :: Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a

+ Control.Monad.Trans.MSF.Except: withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a

- Control.Monad.Trans.MSF.List: ListT :: m [a] -> ListT a

+ Control.Monad.Trans.MSF.List: ListT :: m [a] -> ListT (m :: Type -> Type) a

- Control.Monad.Trans.MSF.List: [runListT] :: ListT a -> m [a]

+ Control.Monad.Trans.MSF.List: [runListT] :: ListT (m :: Type -> Type) a -> m [a]

- Control.Monad.Trans.MSF.List: mapListT :: () => (m [a] -> n [b]) -> ListT m a -> ListT n b

+ Control.Monad.Trans.MSF.List: mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b

- Control.Monad.Trans.MSF.Maybe: MaybeT :: m (Maybe a) -> MaybeT a

+ Control.Monad.Trans.MSF.Maybe: MaybeT :: m (Maybe a) -> MaybeT (m :: Type -> Type) a

- Control.Monad.Trans.MSF.Maybe: [runMaybeT] :: MaybeT a -> m (Maybe a)

+ Control.Monad.Trans.MSF.Maybe: [runMaybeT] :: MaybeT (m :: Type -> Type) a -> m (Maybe a)

- Control.Monad.Trans.MSF.Maybe: exceptToMaybeT :: Functor m => ExceptT e m a -> MaybeT m a

+ Control.Monad.Trans.MSF.Maybe: exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a

- Control.Monad.Trans.MSF.Maybe: mapMaybeT :: () => (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b

+ Control.Monad.Trans.MSF.Maybe: mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b

- Control.Monad.Trans.MSF.Maybe: maybeToExceptT :: Functor m => e -> MaybeT m a -> ExceptT e m a

+ Control.Monad.Trans.MSF.Maybe: maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a

- Control.Monad.Trans.MSF.RWS: RWST :: (r -> s -> m (a, s, w)) -> RWST r w s a

+ Control.Monad.Trans.MSF.RWS: RWST :: (r -> s -> m (a, s, w)) -> RWST r w s (m :: Type -> Type) a

- Control.Monad.Trans.MSF.RWS: [runRWST] :: RWST r w s a -> r -> s -> m (a, s, w)

+ Control.Monad.Trans.MSF.RWS: [runRWST] :: RWST r w s (m :: Type -> Type) a -> r -> s -> m (a, s, w)

- Control.Monad.Trans.MSF.RWS: ask :: (Monoid w, Monad m) => RWST r w s m r

+ Control.Monad.Trans.MSF.RWS: ask :: forall w (m :: Type -> Type) r s. (Monoid w, Monad m) => RWST r w s m r

- Control.Monad.Trans.MSF.RWS: asks :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: asks :: forall w (m :: Type -> Type) r a s. (Monoid w, Monad m) => (r -> a) -> RWST r w s m a

- Control.Monad.Trans.MSF.RWS: censor :: Monad m => (w -> w) -> RWST r w s m a -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: censor :: forall (m :: Type -> Type) w r s a. Monad m => (w -> w) -> RWST r w s m a -> RWST r w s m a

- Control.Monad.Trans.MSF.RWS: evalRWS :: () => RWS r w s a -> r -> s -> (a, w)

+ Control.Monad.Trans.MSF.RWS: evalRWS :: RWS r w s a -> r -> s -> (a, w)

- Control.Monad.Trans.MSF.RWS: execRWS :: () => RWS r w s a -> r -> s -> (s, w)

+ Control.Monad.Trans.MSF.RWS: execRWS :: RWS r w s a -> r -> s -> (s, w)

- Control.Monad.Trans.MSF.RWS: get :: (Monoid w, Monad m) => RWST r w s m s

+ Control.Monad.Trans.MSF.RWS: get :: forall w (m :: Type -> Type) r s. (Monoid w, Monad m) => RWST r w s m s

- Control.Monad.Trans.MSF.RWS: gets :: (Monoid w, Monad m) => (s -> a) -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: gets :: forall w (m :: Type -> Type) s a r. (Monoid w, Monad m) => (s -> a) -> RWST r w s m a

- Control.Monad.Trans.MSF.RWS: listen :: Monad m => RWST r w s m a -> RWST r w s m (a, w)

+ Control.Monad.Trans.MSF.RWS: listen :: forall (m :: Type -> Type) r w s a. Monad m => RWST r w s m a -> RWST r w s m (a, w)

- Control.Monad.Trans.MSF.RWS: listens :: Monad m => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)

+ Control.Monad.Trans.MSF.RWS: listens :: forall (m :: Type -> Type) w b r s a. Monad m => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)

- Control.Monad.Trans.MSF.RWS: local :: () => (r -> r) -> RWST r w s m a -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: local :: forall r w s (m :: Type -> Type) a. (r -> r) -> RWST r w s m a -> RWST r w s m a

- Control.Monad.Trans.MSF.RWS: mapRWS :: () => ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b

+ Control.Monad.Trans.MSF.RWS: mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b

- Control.Monad.Trans.MSF.RWS: mapRWST :: () => (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b

+ Control.Monad.Trans.MSF.RWS: mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b

- Control.Monad.Trans.MSF.RWS: modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()

+ Control.Monad.Trans.MSF.RWS: modify :: forall w (m :: Type -> Type) s r. (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()

- Control.Monad.Trans.MSF.RWS: pass :: Monad m => RWST r w s m (a, w -> w) -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: pass :: forall (m :: Type -> Type) r w s a. Monad m => RWST r w s m (a, w -> w) -> RWST r w s m a

- Control.Monad.Trans.MSF.RWS: put :: (Monoid w, Monad m) => s -> RWST r w s m ()

+ Control.Monad.Trans.MSF.RWS: put :: forall w (m :: Type -> Type) s r. (Monoid w, Monad m) => s -> RWST r w s m ()

- Control.Monad.Trans.MSF.RWS: reader :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: reader :: forall w (m :: Type -> Type) r a s. (Monoid w, Monad m) => (r -> a) -> RWST r w s m a

- Control.Monad.Trans.MSF.RWS: runRWS :: () => RWS r w s a -> r -> s -> (a, s, w)

+ Control.Monad.Trans.MSF.RWS: runRWS :: RWS r w s a -> r -> s -> (a, s, w)

- Control.Monad.Trans.MSF.RWS: rws :: () => (r -> s -> (a, s, w)) -> RWS r w s a

+ Control.Monad.Trans.MSF.RWS: rws :: (r -> s -> (a, s, w)) -> RWS r w s a

- Control.Monad.Trans.MSF.RWS: state :: (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: state :: forall w (m :: Type -> Type) s a r. (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a

- Control.Monad.Trans.MSF.RWS: tell :: Monad m => w -> RWST r w s m ()

+ Control.Monad.Trans.MSF.RWS: tell :: forall (m :: Type -> Type) w r s. Monad m => w -> RWST r w s m ()

- Control.Monad.Trans.MSF.RWS: withRWS :: () => (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a

+ Control.Monad.Trans.MSF.RWS: withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a

- Control.Monad.Trans.MSF.RWS: withRWST :: () => (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a

+ Control.Monad.Trans.MSF.RWS: withRWST :: forall r' s r w (m :: Type -> Type) a. (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a

- Control.Monad.Trans.MSF.RWS: writer :: Monad m => (a, w) -> RWST r w s m a

+ Control.Monad.Trans.MSF.RWS: writer :: forall (m :: Type -> Type) a w r s. Monad m => (a, w) -> RWST r w s m a

- Control.Monad.Trans.MSF.Reader: ReaderT :: (r -> m a) -> ReaderT r

+ Control.Monad.Trans.MSF.Reader: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a

- Control.Monad.Trans.MSF.Reader: [runReaderT] :: ReaderT r -> r -> m a

+ Control.Monad.Trans.MSF.Reader: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a

- Control.Monad.Trans.MSF.Reader: ask :: Monad m => ReaderT r m r

+ Control.Monad.Trans.MSF.Reader: ask :: forall (m :: Type -> Type) r. Monad m => ReaderT r m r

- Control.Monad.Trans.MSF.Reader: asks :: Monad m => (r -> a) -> ReaderT r m a

+ Control.Monad.Trans.MSF.Reader: asks :: forall (m :: Type -> Type) r a. Monad m => (r -> a) -> ReaderT r m a

- Control.Monad.Trans.MSF.Reader: local :: () => (r -> r) -> ReaderT r m a -> ReaderT r m a

+ Control.Monad.Trans.MSF.Reader: local :: forall r (m :: Type -> Type) a. (r -> r) -> ReaderT r m a -> ReaderT r m a

- Control.Monad.Trans.MSF.Reader: mapReader :: () => (a -> b) -> Reader r a -> Reader r b

+ Control.Monad.Trans.MSF.Reader: mapReader :: (a -> b) -> Reader r a -> Reader r b

- Control.Monad.Trans.MSF.Reader: mapReaderT :: () => (m a -> n b) -> ReaderT r m a -> ReaderT r n b

+ Control.Monad.Trans.MSF.Reader: mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b

- Control.Monad.Trans.MSF.Reader: reader :: Monad m => (r -> a) -> ReaderT r m a

+ Control.Monad.Trans.MSF.Reader: reader :: forall (m :: Type -> Type) r a. Monad m => (r -> a) -> ReaderT r m a

- Control.Monad.Trans.MSF.Reader: runReader :: () => Reader r a -> r -> a

+ Control.Monad.Trans.MSF.Reader: runReader :: Reader r a -> r -> a

- Control.Monad.Trans.MSF.Reader: withReader :: () => (r' -> r) -> Reader r a -> Reader r' a

+ Control.Monad.Trans.MSF.Reader: withReader :: (r' -> r) -> Reader r a -> Reader r' a

- Control.Monad.Trans.MSF.Reader: withReaderT :: () => (r' -> r) -> ReaderT r m a -> ReaderT r' m a

+ Control.Monad.Trans.MSF.Reader: withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a

- Control.Monad.Trans.MSF.State: StateT :: (s -> m (a, s)) -> StateT s a

+ Control.Monad.Trans.MSF.State: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a

- Control.Monad.Trans.MSF.State: [runStateT] :: StateT s a -> s -> m (a, s)

+ Control.Monad.Trans.MSF.State: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)

- Control.Monad.Trans.MSF.State: evalState :: () => State s a -> s -> a

+ Control.Monad.Trans.MSF.State: evalState :: State s a -> s -> a

- Control.Monad.Trans.MSF.State: execState :: () => State s a -> s -> s

+ Control.Monad.Trans.MSF.State: execState :: State s a -> s -> s

- Control.Monad.Trans.MSF.State: get :: Monad m => StateT s m s

+ Control.Monad.Trans.MSF.State: get :: forall (m :: Type -> Type) s. Monad m => StateT s m s

- Control.Monad.Trans.MSF.State: gets :: Monad m => (s -> a) -> StateT s m a

+ Control.Monad.Trans.MSF.State: gets :: forall (m :: Type -> Type) s a. Monad m => (s -> a) -> StateT s m a

- Control.Monad.Trans.MSF.State: liftCallCC' :: () => CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b

+ Control.Monad.Trans.MSF.State: liftCallCC' :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b

- Control.Monad.Trans.MSF.State: mapState :: () => ((a, s) -> (b, s)) -> State s a -> State s b

+ Control.Monad.Trans.MSF.State: mapState :: ((a, s) -> (b, s)) -> State s a -> State s b

- Control.Monad.Trans.MSF.State: mapStateT :: () => (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

+ Control.Monad.Trans.MSF.State: mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

- Control.Monad.Trans.MSF.State: modify :: Monad m => (s -> s) -> StateT s m ()

+ Control.Monad.Trans.MSF.State: modify :: forall (m :: Type -> Type) s. Monad m => (s -> s) -> StateT s m ()

- Control.Monad.Trans.MSF.State: modify' :: Monad m => (s -> s) -> StateT s m ()

+ Control.Monad.Trans.MSF.State: modify' :: forall (m :: Type -> Type) s. Monad m => (s -> s) -> StateT s m ()

- Control.Monad.Trans.MSF.State: put :: Monad m => s -> StateT s m ()

+ Control.Monad.Trans.MSF.State: put :: forall (m :: Type -> Type) s. Monad m => s -> StateT s m ()

- Control.Monad.Trans.MSF.State: runState :: () => State s a -> s -> (a, s)

+ Control.Monad.Trans.MSF.State: runState :: State s a -> s -> (a, s)

- Control.Monad.Trans.MSF.State: state :: Monad m => (s -> (a, s)) -> StateT s m a

+ Control.Monad.Trans.MSF.State: state :: forall (m :: Type -> Type) s a. Monad m => (s -> (a, s)) -> StateT s m a

- Control.Monad.Trans.MSF.State: withState :: () => (s -> s) -> State s a -> State s a

+ Control.Monad.Trans.MSF.State: withState :: (s -> s) -> State s a -> State s a

- Control.Monad.Trans.MSF.State: withStateT :: () => (s -> s) -> StateT s m a -> StateT s m a

+ Control.Monad.Trans.MSF.State: withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a

- Control.Monad.Trans.MSF.Writer: WriterT :: m (a, w) -> WriterT w a

+ Control.Monad.Trans.MSF.Writer: WriterT :: m (a, w) -> WriterT w (m :: Type -> Type) a

- Control.Monad.Trans.MSF.Writer: [runWriterT] :: WriterT w a -> m (a, w)

+ Control.Monad.Trans.MSF.Writer: [runWriterT] :: WriterT w (m :: Type -> Type) a -> m (a, w)

- Control.Monad.Trans.MSF.Writer: censor :: Monad m => (w -> w) -> WriterT w m a -> WriterT w m a

+ Control.Monad.Trans.MSF.Writer: censor :: forall (m :: Type -> Type) w a. Monad m => (w -> w) -> WriterT w m a -> WriterT w m a

- Control.Monad.Trans.MSF.Writer: execWriter :: () => Writer w a -> w

+ Control.Monad.Trans.MSF.Writer: execWriter :: Writer w a -> w

- Control.Monad.Trans.MSF.Writer: listen :: Monad m => WriterT w m a -> WriterT w m (a, w)

+ Control.Monad.Trans.MSF.Writer: listen :: forall (m :: Type -> Type) w a. Monad m => WriterT w m a -> WriterT w m (a, w)

- Control.Monad.Trans.MSF.Writer: listens :: Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b)

+ Control.Monad.Trans.MSF.Writer: listens :: forall (m :: Type -> Type) w b a. Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b)

- Control.Monad.Trans.MSF.Writer: mapWriter :: () => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b

+ Control.Monad.Trans.MSF.Writer: mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b

- Control.Monad.Trans.MSF.Writer: mapWriterT :: () => (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b

+ Control.Monad.Trans.MSF.Writer: mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b

- Control.Monad.Trans.MSF.Writer: runWriter :: () => Writer w a -> (a, w)

+ Control.Monad.Trans.MSF.Writer: runWriter :: Writer w a -> (a, w)

- Control.Monad.Trans.MSF.Writer: tell :: Monad m => w -> WriterT w m ()

+ Control.Monad.Trans.MSF.Writer: tell :: forall (m :: Type -> Type) w. Monad m => w -> WriterT w m ()

- Control.Monad.Trans.MSF.Writer: writer :: Monad m => (a, w) -> WriterT w m a

+ Control.Monad.Trans.MSF.Writer: writer :: forall (m :: Type -> Type) a w. Monad m => (a, w) -> WriterT w m a

Files

dunai.cabal +1/−1
src/Control/Monad/Trans/MSF/Random.hs +0/−2
src/Data/MonadicStreamFunction/Core.hs +0/−17

dunai.cabal view

@@ -1,5 +1,5 @@ name:                dunai-version:             0.7.0+version:             0.8.0 synopsis:            Generalised reactive framework supporting classic, arrowized and monadic FRP. homepage:            https://github.com/ivanperez-keera/dunai description:

src/Control/Monad/Trans/MSF/Random.hs view

@@ -7,8 +7,6 @@ --   Under the hood, 'RandT' is basically just 'StateT', --   with the current random number generator as mutable state. --{-# LANGUAGE Arrows              #-} module Control.Monad.Trans.MSF.Random   (     runRandS

src/Data/MonadicStreamFunction/Core.hs view

@@ -170,20 +170,3 @@     --     --  morph' :: (forall c . (a -> m1 (b, c)) -> (a -> m2 (b, c)))         morph' m1F = morph . m1F---- IPerez: There is an alternative signature for liftMStreamPurer that also--- works, and makes the code simpler:------ morphS :: Monad m => (m1 (b, MSF m1 a b) -> m (b, MSF m1 a b)) -> MSF m1 a b -> MSF m a b------ Then we can express:------ liftTransS = morphS lift--- liftBaseS  = morphS liftBase------ We could also define a strict version of morphS as follows:------ morphS'  f = morphS (f >=> whnfVal)---   where whnfVal p@(b,_) = b `seq` return p------ and leave morphS as a lazy version (by default).