Potoki.Core.Consume

Documentation

newtype Consume input output

Active consumer of input into output. Sort of like a reducer in Map/Reduce.

Automates the management of resources.

Constructors

Consume (Fetch input -> IO output)

An action, which executes the provided fetch in IO, while managing the resources behind the scenes.

apConcurrently :: Consume a (b -> c) -> Consume a b -> Consume a c

list :: Consume input [input]

sum :: Num num => Consume num num

transform :: Transform input1 input2 -> Consume input2 output -> Consume input1 output

count :: Consume input Int

head :: Consume input (Maybe input)

last :: Consume input (Maybe input)

reverseList :: Consume input [input]

A faster alternative to "list", which however constructs the list in the reverse order.

vector :: Consume input (Vector input)

concat :: Monoid monoid => Consume monoid monoid

fold :: Fold input output -> Consume input output

foldInIO :: FoldM IO input output -> Consume input output

folding :: Fold a b -> Consume a c -> Consume a (b, c)

foldingInIO :: FoldM IO a b -> Consume a c -> Consume a (b, c)

execState :: (a -> State s b) -> s -> Consume a s

writeBytesToFile :: FilePath -> Consume ByteString (Either IOException ())

Overwrite a file.

• Exception-free
• Automatic resource management

appendBytesToFile :: FilePath -> Consume ByteString (Either IOException ())

Append to a file.

• Exception-free
• Automatic resource management

deleteFiles :: Consume FilePath (Either IOException ())

printBytes :: Consume ByteString ()

printText :: Consume Text ()

printString :: Consume String ()

parseBytes :: Parser output -> Consume ByteString (Either Text output)

parseText :: Parser output -> Consume Text (Either Text output)

concurrently :: Int -> Consume a b -> Consume b c -> Consume a c

Execute a Consume concurrently and consume its results.

Orphan instances

Profunctor Consume

Methods

dimap :: (a -> b) -> (c -> d) -> Consume b c -> Consume a d

lmap :: (a -> b) -> Consume b c -> Consume a c

rmap :: (b -> c) -> Consume a b -> Consume a c

(#.) :: Coercible * c b => q b c -> Consume a b -> Consume a c

(.#) :: Coercible * b a => Consume b c -> q a b -> Consume a c

Choice Consume

Methods

left' :: Consume a b -> Consume (Either a c) (Either b c)

right' :: Consume a b -> Consume (Either c a) (Either c b)

Monad (Consume a)

Methods

(>>=) :: Consume a a -> (a -> Consume a b) -> Consume a b

(>>) :: Consume a a -> Consume a b -> Consume a b

return :: a -> Consume a a

fail :: String -> Consume a a

Functor (Consume input)

Methods

fmap :: (a -> b) -> Consume input a -> Consume input b

(<$) :: a -> Consume input b -> Consume input a

Applicative (Consume a)

Methods

pure :: a -> Consume a a

(<*>) :: Consume a (a -> b) -> Consume a a -> Consume a b

(*>) :: Consume a a -> Consume a b -> Consume a b

(<*) :: Consume a a -> Consume a b -> Consume a a

MonadIO (Consume a)

Methods

liftIO :: IO a -> Consume a a