    module Data.Array.Repa.Repr.ByteString
            ( B, Array (..)
            , fromByteString, toByteString)
    where
    import Data.Array.Repa.Shape
    import Data.Array.Repa.Base
    import Data.Array.Repa.Repr.Delayed
    import Data.Word
    import qualified Data.ByteString        as B
    import qualified Data.ByteString.Unsafe as BU
    import Data.ByteString                  (ByteString)

    -- | Strict ByteStrings arrays are represented as ForeignPtr buffers of Word8
    data B

    -- | Read elements from a `ByteString`.
    instance Source B Word8 where
     data Array B sh Word8
            = AByteString !sh !ByteString

     linearIndex :: Array B sh Word8 -> Int -> Word8
    linearIndex (AByteString _ bs) ix :: Int
    ix
            = ByteString
    bs ByteString -> Int -> Word8
    `B.index` Int
    ix
     {-# INLINE linearIndex #-}

     unsafeLinearIndex :: Array B sh Word8 -> Int -> Word8
    unsafeLinearIndex (AByteString _ bs) ix :: Int
    ix
            = ByteString
    bs ByteString -> Int -> Word8
    `BU.unsafeIndex` Int
    ix
     {-# INLINE unsafeLinearIndex #-}

     extent :: Array B sh Word8 -> sh
    extent (AByteString sh _)
            = sh
    sh
     {-# INLINE extent #-}

     deepSeqArray :: Array B sh Word8 -> b -> b
    deepSeqArray (AByteString sh bs) x :: b
    x
      = sh
    sh sh -> b -> b
    forall sh a. Shape sh => sh -> a -> a
    `deepSeq` ByteString
    bs ByteString -> b -> b
    forall a b. a -> b -> b
    `seq` b
    x
     {-# INLINE deepSeqArray #-}

    deriving instance Show sh
            => Show (Array B sh Word8)

    deriving instance Read sh
            => Read (Array B sh Word8)

    -- Conversions ----------------------------------------------------------------
    -- | O(1). Wrap a `ByteString` as an array.
    fromByteString
            :: sh -> ByteString -> Array B sh Word8
    fromByteString :: sh -> ByteString -> Array B sh Word8
    fromByteString sh :: sh
    sh bs :: ByteString
    bs
            = sh -> ByteString -> Array B sh Word8
    forall sh. sh -> ByteString -> Array B sh Word8
    AByteString sh
    sh ByteString
    bs
    {-# INLINE fromByteString #-}

    -- | O(1). Unpack a `ByteString` from an array.
    toByteString :: Array B sh Word8 -> ByteString
    toByteString :: Array B sh Word8 -> ByteString
    toByteString (AByteString _ bs) = ByteString
    bs
    {-# INLINE toByteString #-}