io-streams-1.5.2.2: Simple, composable, and easy-to-use stream I/O

Safe Haskell | None
Language | Haskell2010

System.IO.Streams.List

Contents

- List conversions
- Utility

Description

List conversions and utilities.

Synopsis

- fromList :: [c] -> IO (InputStream c)
- toList :: InputStream a -> IO [a]
- outputToList :: (OutputStream a -> IO b) -> IO [a]
- writeList :: [a] -> OutputStream a -> IO ()
- chunkList :: Int -> InputStream a -> IO (InputStream [a])
- chunkListWith :: (a -> Int -> Bool) -> InputStream a -> IO (InputStream [a])
- concatLists :: InputStream [a] -> IO (InputStream a)
- listOutputStream :: IO (OutputStream c, IO [c])

# List conversions

fromList :: [c] -> IO (InputStream c) #

Transforms a list into an `InputStream` that produces no side effects.

    ghci> is <- Streams.fromList [1, 2]
    ghci> replicateM 3 (Streams.read is)
    [Just 1, Just 2, Nothing]

toList :: InputStream a -> IO [a] #

Drains an `InputStream`, converting it to a list. N.B. that this function reads the entire `InputStream` strictly into memory and as such is not recommended for streaming applications or where the size of the input is not bounded or known.

    ghci> is <- Streams.fromList [1, 2]
    ghci> Streams.toList is
    [1, 2]

outputToList :: (OutputStream a -> IO b) -> IO [a] #

Given an IO action that requires an `OutputStream`, creates one and captures all the output the action sends to it as a list.

Example:

    ghci> import Control.Applicative
    ghci> (connect $ fromList ["a", "b", "c"]) >>= outputToList
    ["a","b","c"]

writeList :: [a] -> OutputStream a -> IO () #

Feeds a list to an `OutputStream`. Does not write an end-of-stream to the stream.

    ghci> os <- Streams.unlines Streams.stdout >>= Streams.contramap (S.pack . show) :: IO (OutputStream Int)
    ghci> Streams.writeList [1, 2] os
    1
    2
    ghci> Streams.writeList [3, 4] os
    3
    4

# Utility

chunkList #

Arguments

:: Int | chunk size
-> InputStream a | stream to process
-> IO (InputStream [a]) |

Splits an input stream into chunks of at most size `n`.

Example:

    ghci> fromList [1..14::Int] >>= chunkList 4 >>= toList
    [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14]]

chunkListWith #

Arguments

:: (a -> Int -> Bool) | break predicate
-> InputStream a | stream to process
-> IO (InputStream [a]) |

Splits an input stream into chunks whenever `p elt count` returns true.

Example:

    ghci> fromList [1..14::Int] >>= chunkListWith (x n -> n>=4) >>= toList
    [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14]]
    ghci> fromList [a..z] >>= chunkListWith (x n -> n>=4 && x elem "aeiouy") >>= toList
    ["abcde","fghi","jklmno","pqrstu","vwxy","z"]

Since: 1.3.3.0.

concatLists :: InputStream [a] -> IO (InputStream a) #

Given an input stream containing lists, produces a new input stream that will yield the concatenation of these lists. See `concat`.

Example:

    ghci> Streams.fromList [[1,2,3::Int], [4,5,6]] >>=
          Streams.concatLists >>=
          Streams.toList
    [1,2,3,4,5,6]

listOutputStream :: IO (OutputStream c, IO [c]) #

`listOutputStream` returns an `OutputStream` which stores values fed into it and an action which flushes all stored values to a list.

The flush action resets the store.

Note that this function will buffer any input sent to it on the heap. Please don't use this unless you're sure that the amount of input provided is bounded and will fit in memory without issues.

    ghci> (os, flush) <- Streams.listOutputStream :: IO (OutputStream Int, IO [Int])
    ghci> Streams.writeList [1, 2] os
    ghci> flush
    [1, 2]
    ghci> Streams.writeList [3, 4] os
    ghci> flush
    [3, 4]