 storablevector0.2.1: Fast, packed, strict storable arrays with a list interface like ByteString  Source code  Contents  Index 





Description 
Chunky signal stream build on StorableVector.
Hints for fusion:
 Higher order functions should always be inlined in the end
in order to turn them into machine loops
instead of calling a function in an inner loop.


Synopsis 

newtype Vector a = SV {}   newtype ChunkSize = ChunkSize Int   chunkSize :: Int > ChunkSize   defaultChunkSize :: ChunkSize   empty :: Storable a => Vector a   singleton :: Storable a => a > Vector a   fromChunks :: Storable a => [Vector a] > Vector a   pack :: Storable a => ChunkSize > [a] > Vector a   unpack :: Storable a => Vector a > [a]   packWith :: Storable b => ChunkSize > (a > b) > [a] > Vector b   unpackWith :: Storable a => (a > b) > Vector a > [b]   unfoldr :: Storable b => ChunkSize > (a > Maybe (b, a)) > a > Vector b   iterate :: Storable a => ChunkSize > (a > a) > a > Vector a   repeat :: Storable a => ChunkSize > a > Vector a   cycle :: Storable a => Vector a > Vector a   replicate :: Storable a => ChunkSize > Int > a > Vector a   null :: Storable a => Vector a > Bool   length :: Vector a > Int   cons :: Storable a => a > Vector a > Vector a   append :: Storable a => Vector a > Vector a > Vector a   extendL :: Storable a => ChunkSize > Vector a > Vector a > Vector a   concat :: Storable a => [Vector a] > Vector a   map :: (Storable x, Storable y) => (x > y) > Vector x > Vector y   reverse :: Storable a => Vector a > Vector a   foldl :: Storable b => (a > b > a) > a > Vector b > a   foldl' :: Storable b => (a > b > a) > a > Vector b > a   any :: Storable a => (a > Bool) > Vector a > Bool   all :: Storable a => (a > Bool) > Vector a > Bool   maximum :: (Storable a, Ord a) => Vector a > a   minimum :: (Storable a, Ord a) => Vector a > a   viewL :: Storable a => Vector a > Maybe (a, Vector a)   viewR :: Storable a => Vector a > Maybe (Vector a, a)   switchL :: Storable a => b > (a > Vector a > b) > Vector a > b   switchR :: Storable a => b > (Vector a > a > b) > Vector a > b   scanl :: (Storable a, Storable b) => (a > b > a) > a > Vector b > Vector a   mapAccumL :: (Storable a, Storable b) => (acc > a > (acc, b)) > acc > Vector a > (acc, Vector b)   mapAccumR :: (Storable a, Storable b) => (acc > a > (acc, b)) > acc > Vector a > (acc, Vector b)   crochetLChunk :: (Storable x, Storable y) => (x > acc > Maybe (y, acc)) > acc > Vector x > (Vector y, Maybe acc)   crochetL :: (Storable x, Storable y) => (x > acc > Maybe (y, acc)) > acc > Vector x > Vector y   take :: Storable a => Int > Vector a > Vector a   drop :: Storable a => Int > Vector a > Vector a   splitAt :: Storable a => Int > Vector a > (Vector a, Vector a)   dropMarginRem :: Storable a => Int > Int > Vector a > (Int, Vector a)   dropMargin :: Storable a => Int > Int > Vector a > Vector a   dropWhile :: Storable a => (a > Bool) > Vector a > Vector a   takeWhile :: Storable a => (a > Bool) > Vector a > Vector a   span :: Storable a => (a > Bool) > Vector a > (Vector a, Vector a)   filter :: Storable a => (a > Bool) > Vector a > Vector a   zipWith :: (Storable a, Storable b, Storable c) => (a > b > c) > Vector a > Vector b > Vector c   zipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (a > b > c > d) > Vector a > Vector b > Vector c > Vector d   zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a > b > c > d > e) > Vector a > Vector b > Vector c > Vector d > Vector e   zipWithSize :: (Storable a, Storable b, Storable c) => ChunkSize > (a > b > c) > Vector a > Vector b > Vector c   zipWithSize3 :: (Storable a, Storable b, Storable c, Storable d) => ChunkSize > (a > b > c > d) > Vector a > Vector b > Vector c > Vector d   zipWithSize4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => ChunkSize > (a > b > c > d > e) > Vector a > Vector b > Vector c > Vector d > Vector e   pad :: Storable a => ChunkSize > a > Int > Vector a > Vector a   padAlt :: Storable a => ChunkSize > a > Int > Vector a > Vector a   cancelNullVector :: (Vector a, b) > Maybe (Vector a, b)   fromChunk :: Storable a => Vector a > Vector a   hGetContentsAsync :: Storable a => ChunkSize > Handle > IO (IOError, Vector a)   hPut :: Storable a => Handle > Vector a > IO ()   readFileAsync :: Storable a => ChunkSize > FilePath > IO (IOError, Vector a)   writeFile :: Storable a => FilePath > Vector a > IO ()   appendFile :: Storable a => FilePath > Vector a > IO () 


Documentation 











Introducing and eliminating Vectors


























Basic interface











extendL size x y
prepends the chunk x and merges it with the first chunk of y
if the total size is at most size.
This way you can prepend small chunks
while asserting a reasonable average size for chunks.




Transformations






Reducing Vectors














inspecting a vector




















subvectors









dropMarginRem n m xs
drops at most the first m elements of xs
and ensures that xs still contains n elements.
Additionally returns the number of elements that could not be dropped
due to the margin constraint.
That is dropMarginRem n m xs == (k,ys) implies length xs  m == length ys  k.
Requires length xs >= n.










other functions

















Ensure a minimal length of the list by appending pad values.




Helper functions for StorableVector






IO



Read the rest of a file lazily and
provide the reason of termination as IOError.
If IOError is EOF (check with System.Error.isEOFError err),
then the file was read successfully.
Only access the final IOError after you have consumed the file contents,
since finding out the terminating reason forces to read the entire file.
Make also sure you read the file completely,
because it is only closed when the file end is reached
(or an exception is encountered).
TODO:
In ByteString.Lazy the chunk size is reduced
if data is not immediately available.
Maybe we should adapt that behaviour
but when working with realtime streams
that may mean that the chunks are very small.





The file can only closed after all values are consumed.
That is you must always assert that you consume all elements of the stream,
and that no values are missed due to lazy evaluation.
This requirement makes this function useless in many applications.






Produced by Haddock version 2.4.2 