Servant.Types.SourceT

Documentation

>>> :set -XOverloadedStrings
>>> import Control.Monad.Except (runExcept)
>>> import Data.Foldable (toList)
>>> import qualified Data.Attoparsec.ByteString.Char8 as A8

newtype SourceT m a

This is CPSised ListT.

Since: 0.15

Constructors

SourceT

Fields

• unSourceT :: forall b. (StepT m a -> m b) -> m b

Instances

MonadIO m => FromSourceIO a (SourceT m a)

Defined in Servant.API.Stream

Methods

fromSourceIO :: SourceIO a -> SourceT m a

SourceToSourceIO m => ToSourceIO chunk (SourceT m chunk)

Relax to use auxiliary class, have m

Defined in Servant.API.Stream

Methods

toSourceIO :: SourceT m chunk -> SourceIO chunk

Functor m => Functor (SourceT m)

Defined in Servant.Types.SourceT

Methods

fmap :: (a -> b) -> SourceT m a -> SourceT m b

(<$) :: a -> SourceT m b -> SourceT m a

Identity ~ m => Foldable (SourceT m)

>>> toList (source [1..10])
[1,2,3,4,5,6,7,8,9,10]

Defined in Servant.Types.SourceT

Methods

fold :: Monoid m0 => SourceT m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> SourceT m a -> m0

foldr :: (a -> b -> b) -> b -> SourceT m a -> b

foldr' :: (a -> b -> b) -> b -> SourceT m a -> b

foldl :: (b -> a -> b) -> b -> SourceT m a -> b

foldl' :: (b -> a -> b) -> b -> SourceT m a -> b

foldr1 :: (a -> a -> a) -> SourceT m a -> a

foldl1 :: (a -> a -> a) -> SourceT m a -> a

toList :: SourceT m a -> [a]

null :: SourceT m a -> Bool

length :: SourceT m a -> Int

elem :: Eq a => a -> SourceT m a -> Bool

maximum :: Ord a => SourceT m a -> a

minimum :: Ord a => SourceT m a -> a

sum :: Num a => SourceT m a -> a

product :: Num a => SourceT m a -> a

(Applicative m, Show1 m) => Show1 (SourceT m)

Defined in Servant.Types.SourceT

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> SourceT m a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [SourceT m a] -> ShowS

MFunctor SourceT

>>> hoist (Just . runIdentity) (source [1..3]) :: SourceT Maybe Int
fromStepT (Effect (Just (Yield 1 (Yield 2 (Yield 3 Stop)))))

Defined in Servant.Types.SourceT

Methods

hoist :: Monad m => (forall a. m a -> n a) -> SourceT m b -> SourceT n b

(Applicative m, Show1 m, Show a) => Show (SourceT m a)

Defined in Servant.Types.SourceT

Methods

showsPrec :: Int -> SourceT m a -> ShowS

show :: SourceT m a -> String

showList :: [SourceT m a] -> ShowS

Functor m => Semigroup (SourceT m a)

>>> source "xy" <> source "z" :: SourceT Identity Char
fromStepT (Effect (Identity (Yield 'x' (Yield 'y' (Yield 'z' Stop)))))

Defined in Servant.Types.SourceT

Methods

(<>) :: SourceT m a -> SourceT m a -> SourceT m a

sconcat :: NonEmpty (SourceT m a) -> SourceT m a

stimes :: Integral b => b -> SourceT m a -> SourceT m a

Functor m => Monoid (SourceT m a)

>>> mempty :: SourceT Maybe Int
fromStepT (Effect (Just Stop))

Defined in Servant.Types.SourceT

Methods

mempty :: SourceT m a

mappend :: SourceT m a -> SourceT m a -> SourceT m a

mconcat :: [SourceT m a] -> SourceT m a

(Arbitrary a, Monad m) => Arbitrary (SourceT m a)

Doesn't generate Error constructors. SourceT doesn't shrink.

Defined in Servant.Types.SourceT

Methods

arbitrary :: Gen (SourceT m a)

shrink :: SourceT m a -> [SourceT m a]

mapStepT :: (StepT m a -> StepT m b) -> SourceT m a -> SourceT m b

data StepT m a

ListT with additional constructors.

Since: 0.15

Constructors

Stop

Error String

Skip (StepT m a)

Yield a (StepT m a)

Effect (m (StepT m a))

Instances

MonadTrans StepT

>>> lift [1,2,3] :: StepT [] Int
Effect [Yield 1 Stop,Yield 2 Stop,Yield 3 Stop]

Defined in Servant.Types.SourceT

Methods

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

Functor m => Functor (StepT m)

Defined in Servant.Types.SourceT

Methods

fmap :: (a -> b) -> StepT m a -> StepT m b

(<$) :: a -> StepT m b -> StepT m a

Identity ~ m => Foldable (StepT m)

Defined in Servant.Types.SourceT

Methods

fold :: Monoid m0 => StepT m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> StepT m a -> m0

foldr :: (a -> b -> b) -> b -> StepT m a -> b

foldr' :: (a -> b -> b) -> b -> StepT m a -> b

foldl :: (b -> a -> b) -> b -> StepT m a -> b

foldl' :: (b -> a -> b) -> b -> StepT m a -> b

foldr1 :: (a -> a -> a) -> StepT m a -> a

foldl1 :: (a -> a -> a) -> StepT m a -> a

toList :: StepT m a -> [a]

null :: StepT m a -> Bool

length :: StepT m a -> Int

elem :: Eq a => a -> StepT m a -> Bool

maximum :: Ord a => StepT m a -> a

minimum :: Ord a => StepT m a -> a

sum :: Num a => StepT m a -> a

product :: Num a => StepT m a -> a

(Applicative m, Show1 m) => Show1 (StepT m)

Defined in Servant.Types.SourceT

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> StepT m a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [StepT m a] -> ShowS

MFunctor StepT

Defined in Servant.Types.SourceT

Methods

hoist :: Monad m => (forall a. m a -> n a) -> StepT m b -> StepT n b

(Applicative m, Show1 m, Show a) => Show (StepT m a)

Defined in Servant.Types.SourceT

Methods

showsPrec :: Int -> StepT m a -> ShowS

show :: StepT m a -> String

showList :: [StepT m a] -> ShowS

Functor m => Semigroup (StepT m a)

Defined in Servant.Types.SourceT

Methods

(<>) :: StepT m a -> StepT m a -> StepT m a

sconcat :: NonEmpty (StepT m a) -> StepT m a

stimes :: Integral b => b -> StepT m a -> StepT m a

Functor m => Monoid (StepT m a)

>>> mempty :: StepT [] Int
Stop

>>> mempty :: StepT Identity Int
Stop

Defined in Servant.Types.SourceT

Methods

mempty :: StepT m a

mappend :: StepT m a -> StepT m a -> StepT m a

mconcat :: [StepT m a] -> StepT m a

(Arbitrary a, Monad m) => Arbitrary (StepT m a)

Doesn't generate Error constructors.

Defined in Servant.Types.SourceT

Methods

arbitrary :: Gen (StepT m a)

shrink :: StepT m a -> [StepT m a]

fromStepT :: StepT m a -> SourceT m a

Create SourceT from Step.

Note: often enough you want to use SourceT directly.

source :: [a] -> SourceT m a

Create pure SourceT.

>>> source "foo" :: SourceT Identity Char
fromStepT (Effect (Identity (Yield 'f' (Yield 'o' (Yield 'o' Stop)))))

runSourceT :: Monad m => SourceT m a -> ExceptT String m [a]

Get the answers.

>>> runSourceT (source "foo" :: SourceT Identity Char)
ExceptT (Identity (Right "foo"))

>>> runSourceT (source "foo" :: SourceT [] Char)
ExceptT [Right "foo"]

runStepT :: Monad m => StepT m a -> ExceptT String m [a]

mapMaybe :: Functor m => (a -> Maybe b) -> SourceT m a -> SourceT m b

Filter values.

>>> toList $ mapMaybe (\x -> if odd x then Just x else Nothing) (source [0..10]) :: [Int]
[1,3,5,7,9]

>>> mapMaybe (\x -> if odd x then Just x else Nothing) (source [0..2]) :: SourceT Identity Int
fromStepT (Effect (Identity (Skip (Yield 1 (Skip Stop)))))

Illustrates why we need Skip.

mapMaybeStep :: Functor m => (a -> Maybe b) -> StepT m a -> StepT m b

foreach

Arguments

:: Monad m

=> (String -> m ())

error handler

-> (a -> m ())

-> SourceT m a

-> m ()

Run action for each value in the SourceT.

>>> foreach fail print (source "abc")
'a'
'b'
'c'

foreachStep

Arguments

:: Monad m

=> (String -> m ())

error handler

-> (a -> m ())

-> StepT m a

-> m ()

See foreach.

fromAction :: Functor m => (a -> Bool) -> m a -> SourceT m a

fromActionStep :: Functor m => (a -> Bool) -> m a -> StepT m a

readFile :: FilePath -> SourceT IO ByteString

Read file.

>>> foreach fail BS.putStr (readFile "servant.cabal")
cabal-version:       >=1.10
name:                servant
...

transformWithAtto :: Monad m => Parser a -> SourceT m ByteString -> SourceT m a

Transform using attoparsec parser.

Note: parser should not accept empty input!

>>> let parser = A.skipWhile A8.isSpace_w8 >> A.takeWhile1 A8.isDigit_w8

>>> runExcept $ runSourceT $ transformWithAtto parser (source ["1 2 3"])
Right ["1","2","3"]

>>> runExcept $ runSourceT $ transformWithAtto parser (source ["1", "2", "3"])
Right ["123"]

>>> runExcept $ runSourceT $ transformWithAtto parser (source ["1", "2 3", "4"])
Right ["12","34"]

>>> runExcept $ runSourceT $ transformWithAtto parser (source ["foobar"])
Left "Failed reading: takeWhile1"

transformStepWithAtto :: forall a m. Monad m => Parser a -> StepT m ByteString -> StepT m a