Wizard

Documentation

newtype WizardT m a infixr 9

A Wizard Monoid, based on ideas expressed by Gabriel Gonzalez at http://www.haskellforall.com/2018/02/the-wizard-monoid.html.

One can view this as Compose, specialised to a single functor.

Constructors

WizardT infixr 9

Fields

• wand :: m (m a)

Instances

MonadTrans WizardT

Methods

lift :: Monad m => m a -> WizardT m a

Monad m => Monad (WizardT m)

Methods

(>>=) :: WizardT m a -> (a -> WizardT m b) -> WizardT m b

(>>) :: WizardT m a -> WizardT m b -> WizardT m b

return :: a -> WizardT m a

fail :: String -> WizardT m a

Functor f => Functor (WizardT f)

Methods

fmap :: (a -> b) -> WizardT f a -> WizardT f b

(<$) :: a -> WizardT f b -> WizardT f a

MonadFix m => MonadFix (WizardT m)

Methods

mfix :: (a -> WizardT m a) -> WizardT m a

(Alternative m, Monad m) => MonadFail (WizardT m)

Methods

fail :: String -> WizardT m a

Applicative f => Applicative (WizardT f)

Methods

pure :: a -> WizardT f a

(<*>) :: WizardT f (a -> b) -> WizardT f a -> WizardT f b

liftA2 :: (a -> b -> c) -> WizardT f a -> WizardT f b -> WizardT f c

(*>) :: WizardT f a -> WizardT f b -> WizardT f b

(<*) :: WizardT f a -> WizardT f b -> WizardT f a

Foldable f => Foldable (WizardT f)

Methods

fold :: Monoid m => WizardT f m -> m

foldMap :: Monoid m => (a -> m) -> WizardT f a -> m

foldr :: (a -> b -> b) -> b -> WizardT f a -> b

foldr' :: (a -> b -> b) -> b -> WizardT f a -> b

foldl :: (b -> a -> b) -> b -> WizardT f a -> b

foldl' :: (b -> a -> b) -> b -> WizardT f a -> b

foldr1 :: (a -> a -> a) -> WizardT f a -> a

foldl1 :: (a -> a -> a) -> WizardT f a -> a

toList :: WizardT f a -> [a]

null :: WizardT f a -> Bool

length :: WizardT f a -> Int

elem :: Eq a => a -> WizardT f a -> Bool

maximum :: Ord a => WizardT f a -> a

minimum :: Ord a => WizardT f a -> a

sum :: Num a => WizardT f a -> a

product :: Num a => WizardT f a -> a

Traversable t => Traversable (WizardT t)

Methods

traverse :: Applicative f => (a -> f b) -> WizardT t a -> f (WizardT t b)

sequenceA :: Applicative f => WizardT t (f a) -> f (WizardT t a)

mapM :: Monad m => (a -> m b) -> WizardT t a -> m (WizardT t b)

sequence :: Monad m => WizardT t (m a) -> m (WizardT t a)

MonadIO m => MonadIO (WizardT m)

Methods

liftIO :: IO a -> WizardT m a

Alternative f => Alternative (WizardT f)

Methods

empty :: WizardT f a

(<|>) :: WizardT f a -> WizardT f a -> WizardT f a

some :: WizardT f a -> WizardT f [a]

many :: WizardT f a -> WizardT f [a]

(Alternative m, Monad m) => MonadPlus (WizardT m)

Methods

mzero :: WizardT m a

mplus :: WizardT m a -> WizardT m a -> WizardT m a

Functor m => Generic1 * (WizardT m)

Associated Types

type Rep1 (WizardT m) (f :: WizardT m -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (WizardT m) f a

to1 :: Rep1 (WizardT m) f a -> f a

Generic (WizardT m a)

Associated Types

type Rep (WizardT m a) :: * -> *

Methods

from :: WizardT m a -> Rep (WizardT m a) x

to :: Rep (WizardT m a) x -> WizardT m a

(Applicative f, Semigroup a) => Semigroup (WizardT f a)

Methods

(<>) :: WizardT f a -> WizardT f a -> WizardT f a

sconcat :: NonEmpty (WizardT f a) -> WizardT f a

stimes :: Integral b => b -> WizardT f a -> WizardT f a

(Applicative f, Monoid a) => Monoid (WizardT f a)

Methods

mempty :: WizardT f a

mappend :: WizardT f a -> WizardT f a -> WizardT f a

mconcat :: [WizardT f a] -> WizardT f a

type Rep1 * (WizardT m)

type Rep1 * (WizardT m) = D1 * (MetaData "WizardT" "Wizard" "wizard-0.1.0.0-8jwooCkpU3C9UiBTufBaPv" True) (C1 * (MetaCons "WizardT" PrefixI True) (S1 * (MetaSel (Just Symbol "wand") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) * * m (Rec1 * m))))

type Rep (WizardT m a)

type Rep (WizardT m a) = D1 * (MetaData "WizardT" "Wizard" "wizard-0.1.0.0-8jwooCkpU3C9UiBTufBaPv" True) (C1 * (MetaCons "WizardT" PrefixI True) (S1 * (MetaSel (Just Symbol "wand") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (m (m a)))))

Fantastical use of a Wizard

egg :: (Applicative f, Monoid a) => WizardT f a

O(1) fantastical - construct an empty Wizard.

tadpole :: Applicative f => a -> WizardT f a

O(1) fantastical - construct a singleton Wizard.

transform :: Functor f => (a -> b) -> WizardT f a -> WizardT f b

Map over a Wizard in a fantastical manner.

essence :: Monad m => WizardT m a -> m a

Get the input (essence) out of the Wizard.

leviosa :: Monad m => m a -> WizardT m a

Lift an input into a Wizard.

summon :: Monad m => (a -> WizardT m b) -> m a -> WizardT m b

Summon a Wizard out of a monad using a conjuring spell.

 '(>>=)' = flip summon . essence

sageMode :: forall m t a b. (Monad m, Foldable t, Monoid a, Monoid b) => (a -> WizardT m b) -> t a -> m b

Run an action over a collection of inputs fantastically.

This is like 'Beast Mode', but specialised to Wizards.

Boring use of a Wizard

empty :: (Applicative f, Monoid a) => WizardT f a

O(1) boring - construct an empty Wizard.

singleton :: Applicative f => a -> WizardT f a

O(1) boring - construct a singleton Wizard.

mapWizard :: Functor f => (a -> b) -> WizardT f a -> WizardT f b

Map over a Wizard in a boring manner.

foldWizard :: forall m t a b. (Monad m, Foldable t, Monoid a, Monoid b) => (a -> WizardT m b) -> t a -> m b

Run an action over a collection of inputs.

Monomophised Wizards

type Wizard a = WizardT Identity a

type WizardAlt f a = WizardT (Alt f) a

type WizardComplex a = WizardT Complex a

type WizardDown a = WizardT Down a

type WizardDual a = WizardT Dual a

type WizardEither a e = WizardT (Either e) a

type WizardEndo a = WizardT ((->) a) a

type WizardF a b = WizardT ((->) b) a

type WizardFirst a = WizardT First a

type WizardGProd f g a = WizardT (f :*: g) a

type WizardIO a = WizardT IO a

type WizardLast a = WizardT Last a

type WizardList a = WizardT [] a

type WizardM1 i c f a = WizardT (M1 i c f) a

type WizardMax a = WizardT Max a

type WizardMaybe a = WizardT Maybe a

type WizardMin a = WizardT Min a

type WizardNonEmpty a = WizardT NonEmpty a

type WizardOption a = WizardT Option a

type WizardPar1 a = WizardT Par1 a

type WizardProduct a = WizardT Product a

type WizardProxy a = WizardT Proxy a

type WizardReadP a = WizardT ReadP a

type WizardReadPrec a = WizardT ReadPrec a

type WizardRec1 f a = WizardT (Rec1 f) a

type WizardST s a = WizardT (ST s) a

type WizardSTM a = WizardT STM a

type WizardSum a = WizardT Sum a

type WizardTuple a = WizardT ((,) a) a

type WizardU1 a = WizardT U1 a