bytestring-0.9.0.3: Fast, packed, strict and lazy byte arrays with a list interfaceSource codeContentsIndex
Data.ByteString.Fusion
Portabilityportable
Stabilityexperimental
Maintainerdons@cse.unsw.edu.au
Contents
Fusion utilities
Alternative Fusion stuff
Strict pairs and sums
Description

Functional array fusion for ByteStrings.

Originally based on code from the Data Parallel Haskell project, http://www.cse.unsw.edu.au/~chak/project/dph

Synopsis
loopU :: AccEFL acc -> acc -> ByteString -> (PairS acc ByteString)
loopL :: AccEFL acc -> acc -> ByteString -> PairS acc ByteString
fuseEFL :: AccEFL acc1 -> AccEFL acc2 -> AccEFL (PairS acc1 acc2)
data NoAcc = NoAcc
loopArr :: (PairS acc arr) -> arr
loopAcc :: (PairS acc arr) -> acc
loopSndAcc :: (PairS (PairS acc1 acc2) arr) -> (PairS acc2 arr)
unSP :: (PairS acc arr) -> (acc, arr)
mapEFL :: (Word8 -> Word8) -> AccEFL NoAcc
filterEFL :: (Word8 -> Bool) -> AccEFL NoAcc
foldEFL :: (acc -> Word8 -> acc) -> AccEFL acc
foldEFL' :: (acc -> Word8 -> acc) -> AccEFL acc
scanEFL :: (Word8 -> Word8 -> Word8) -> AccEFL Word8
mapAccumEFL :: (acc -> Word8 -> (acc, Word8)) -> AccEFL acc
mapIndexEFL :: (Int -> Word8 -> Word8) -> AccEFL Int
loopUp :: AccEFL acc -> acc -> ByteString -> PairS acc ByteString
loopDown :: AccEFL acc -> acc -> ByteString -> PairS acc ByteString
loopNoAcc :: NoAccEFL -> ByteString -> PairS NoAcc ByteString
loopMap :: MapEFL -> ByteString -> PairS NoAcc ByteString
loopFilter :: FilterEFL -> ByteString -> PairS NoAcc ByteString
loopWrapper :: ImperativeLoop acc -> ByteString -> PairS acc ByteString
sequenceLoops :: ImperativeLoop acc1 -> ImperativeLoop acc2 -> ImperativeLoop (PairS acc1 acc2)
doUpLoop :: AccEFL acc -> acc -> ImperativeLoop acc
doDownLoop :: AccEFL acc -> acc -> ImperativeLoop acc
doNoAccLoop :: NoAccEFL -> noAcc -> ImperativeLoop noAcc
doMapLoop :: MapEFL -> noAcc -> ImperativeLoop noAcc
doFilterLoop :: FilterEFL -> noAcc -> ImperativeLoop noAcc
fuseAccAccEFL :: AccEFL acc1 -> AccEFL acc2 -> AccEFL (PairS acc1 acc2)
fuseAccNoAccEFL :: AccEFL acc -> NoAccEFL -> AccEFL (PairS acc noAcc)
fuseNoAccAccEFL :: NoAccEFL -> AccEFL acc -> AccEFL (PairS noAcc acc)
fuseNoAccNoAccEFL :: NoAccEFL -> NoAccEFL -> NoAccEFL
fuseMapAccEFL :: MapEFL -> AccEFL acc -> AccEFL (PairS noAcc acc)
fuseAccMapEFL :: AccEFL acc -> MapEFL -> AccEFL (PairS acc noAcc)
fuseMapNoAccEFL :: MapEFL -> NoAccEFL -> NoAccEFL
fuseNoAccMapEFL :: NoAccEFL -> MapEFL -> NoAccEFL
fuseMapMapEFL :: MapEFL -> MapEFL -> MapEFL
fuseAccFilterEFL :: AccEFL acc -> FilterEFL -> AccEFL (PairS acc noAcc)
fuseFilterAccEFL :: FilterEFL -> AccEFL acc -> AccEFL (PairS noAcc acc)
fuseNoAccFilterEFL :: NoAccEFL -> FilterEFL -> NoAccEFL
fuseFilterNoAccEFL :: FilterEFL -> NoAccEFL -> NoAccEFL
fuseFilterFilterEFL :: FilterEFL -> FilterEFL -> FilterEFL
fuseMapFilterEFL :: MapEFL -> FilterEFL -> NoAccEFL
fuseFilterMapEFL :: FilterEFL -> MapEFL -> NoAccEFL
data PairS a b = !a :*: !b
data MaybeS a
= NothingS
| JustS !a
Fusion utilities
loopUSource
::
=> AccEFL accmapping & folding, once per elem
-> accinitial acc value
-> ByteStringinput ByteString
-> PairS acc ByteString

Iteration over over ByteStrings

Iteration over over ByteStrings

loopLSource
::
=> AccEFL accmapping & folding, once per elem
-> accinitial acc value
-> ByteStringinput ByteString
-> PairS acc ByteString
fuseEFL :: AccEFL acc1 -> AccEFL acc2 -> AccEFL (PairS acc1 acc2)Source
Fuse to flat loop functions
data NoAcc Source
Data type for accumulators which can be ignored. The rewrite rules rely on the fact that no bottoms of this type are ever constructed; hence, we can assume (_ :: NoAcc) seq x = x.
Constructors
NoAcc
loopArr :: (PairS acc arr) -> arrSource
Projection functions that are fusion friendly (as in, we determine when they are inlined)
loopAcc :: (PairS acc arr) -> accSource
loopSndAcc :: (PairS (PairS acc1 acc2) arr) -> (PairS acc2 arr)Source
unSP :: (PairS acc arr) -> (acc, arr)Source
mapEFL :: (Word8 -> Word8) -> AccEFL NoAccSource

Special forms of loop arguments

  • These are common special cases for the three function arguments of gen and loop; we give them special names to make it easier to trigger RULES applying in the special cases represented by these arguments. The INLINE [1] makes sure that these functions are only inlined in the last two simplifier phases.
  • In the case where the accumulator is not needed, it is better to always explicitly return a value `()', rather than just copy the input to the output, as the former gives GHC better local information.

Element function expressing a mapping only

filterEFL :: (Word8 -> Bool) -> AccEFL NoAccSource
Element function implementing a filter function only
foldEFL :: (acc -> Word8 -> acc) -> AccEFL accSource
Element function expressing a reduction only
foldEFL' :: (acc -> Word8 -> acc) -> AccEFL accSource
A strict foldEFL.
scanEFL :: (Word8 -> Word8 -> Word8) -> AccEFL Word8Source
Element function expressing a prefix reduction only
mapAccumEFL :: (acc -> Word8 -> (acc, Word8)) -> AccEFL accSource
Element function implementing a map and fold
mapIndexEFL :: (Int -> Word8 -> Word8) -> AccEFL IntSource
Element function implementing a map with index
Alternative Fusion stuff
This replaces loopU with loopUp and adds several further special cases of loops.
loopUp :: AccEFL acc -> acc -> ByteString -> PairS acc ByteStringSource
loopDown :: AccEFL acc -> acc -> ByteString -> PairS acc ByteStringSource
loopNoAcc :: NoAccEFL -> ByteString -> PairS NoAcc ByteStringSource
loopMap :: MapEFL -> ByteString -> PairS NoAcc ByteStringSource
loopFilter :: FilterEFL -> ByteString -> PairS NoAcc ByteStringSource
loopWrapper :: ImperativeLoop acc -> ByteString -> PairS acc ByteStringSource
sequenceLoops :: ImperativeLoop acc1 -> ImperativeLoop acc2 -> ImperativeLoop (PairS acc1 acc2)Source
doUpLoop :: AccEFL acc -> acc -> ImperativeLoop accSource
doDownLoop :: AccEFL acc -> acc -> ImperativeLoop accSource
doNoAccLoop :: NoAccEFL -> noAcc -> ImperativeLoop noAccSource
doMapLoop :: MapEFL -> noAcc -> ImperativeLoop noAccSource
doFilterLoop :: FilterEFL -> noAcc -> ImperativeLoop noAccSource
These are the special fusion cases for combining each loop form perfectly.
fuseAccAccEFL :: AccEFL acc1 -> AccEFL acc2 -> AccEFL (PairS acc1 acc2)Source
fuseAccNoAccEFL :: AccEFL acc -> NoAccEFL -> AccEFL (PairS acc noAcc)Source
fuseNoAccAccEFL :: NoAccEFL -> AccEFL acc -> AccEFL (PairS noAcc acc)Source
fuseNoAccNoAccEFL :: NoAccEFL -> NoAccEFL -> NoAccEFLSource
fuseMapAccEFL :: MapEFL -> AccEFL acc -> AccEFL (PairS noAcc acc)Source
fuseAccMapEFL :: AccEFL acc -> MapEFL -> AccEFL (PairS acc noAcc)Source
fuseMapNoAccEFL :: MapEFL -> NoAccEFL -> NoAccEFLSource
fuseNoAccMapEFL :: NoAccEFL -> MapEFL -> NoAccEFLSource
fuseMapMapEFL :: MapEFL -> MapEFL -> MapEFLSource
fuseAccFilterEFL :: AccEFL acc -> FilterEFL -> AccEFL (PairS acc noAcc)Source
fuseFilterAccEFL :: FilterEFL -> AccEFL acc -> AccEFL (PairS noAcc acc)Source
fuseNoAccFilterEFL :: NoAccEFL -> FilterEFL -> NoAccEFLSource
fuseFilterNoAccEFL :: FilterEFL -> NoAccEFL -> NoAccEFLSource
fuseFilterFilterEFL :: FilterEFL -> FilterEFL -> FilterEFLSource
fuseMapFilterEFL :: MapEFL -> FilterEFL -> NoAccEFLSource
fuseFilterMapEFL :: FilterEFL -> MapEFL -> NoAccEFLSource
Strict pairs and sums
data PairS a b Source
Strict pair
Constructors
!a :*: !b
show/hide Instances
(Eq a, Eq b) => Eq (PairS a b)
(Ord a, Ord b) => Ord (PairS a b)
(Show a, Show b) => Show (PairS a b)
data MaybeS a Source
Strict Maybe
Constructors
NothingS
JustS !a
show/hide Instances
Eq a => Eq (MaybeS a)
Ord a => Ord (MaybeS a)
Show a => Show (MaybeS a)
Produced by Haddock version 2.1.0