{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE EmptyDataDecls #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StandaloneDeriving #-}
{- |
A special vector type that represents a time-sequence of samples.
This way we can distinguish safely between LLVM vectors
used for parallel signals and pipelines and
those used for chunky processing of scalar signals.
For the chunky processing this data type allows us
to derive the factor from the type
that time constants have to be multiplied with.
-}
module Synthesizer.LLVM.Frame.SerialVector.Class (
   Constant(Constant), constant,

   Read, Element, ReadIt, extract, readStart, readNext,
   Write, WriteIt, insert, writeStart, writeNext, writeStop,
   Zero, writeZero,
   Iterator(Iterator), ReadIterator, WriteIterator, ReadMode, WriteMode,

   Sized, Size, size, sizeOfIterator, withSize,

   insertTraversable, extractTraversable,
   readStartTraversable, readNextTraversable,
   writeStartTraversable, writeNextTraversable, writeStopTraversable,
   writeZeroTraversable,

   dissect, assemble, modify,
   upsample, subsample, last,
   iterate, reverse,
   shiftUp, shiftUpMultiZero, shiftDownMultiZero,
   ) where

import qualified Synthesizer.LLVM.Frame.SerialVector.Code as SerialCode
import qualified Synthesizer.LLVM.Frame.Stereo as Stereo

import qualified LLVM.Extra.Multi.Vector as MultiVector
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.Memory as Memory
import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Extra.Tuple as Tuple

import qualified LLVM.Core as LLVM

import qualified Type.Data.Num.Decimal as TypeNum

import Data.Word (Word32)

import qualified Control.Monad.Trans.State as MS
import qualified Control.Applicative as App
import Control.Monad (foldM, replicateM, (<=<))
import Control.Applicative (liftA2, liftA3, (<$>))

import qualified Data.Traversable as Trav
import qualified Data.List.HT as ListHT
import qualified Data.List as List
import Data.Tuple.HT (mapSnd, fst3, snd3, thd3)

import Prelude hiding (Read, replicate, reverse, iterate, last)



newtype Constant n a = Constant a

constant :: (TypeNum.Positive n) => a -> Constant n a
constant :: forall n a. Positive n => a -> Constant n a
constant = a -> Constant n a
forall n a. a -> Constant n a
Constant

instance Functor (Constant n) where
   fmap :: forall a b. (a -> b) -> Constant n a -> Constant n b
fmap a -> b
f (Constant a
a) = b -> Constant n b
forall n a. a -> Constant n a
Constant (a -> b
f a
a)

instance App.Applicative (Constant n) where
   pure :: forall a. a -> Constant n a
pure = a -> Constant n a
forall n a. a -> Constant n a
Constant
   Constant a -> b
f <*> :: forall a b. Constant n (a -> b) -> Constant n a -> Constant n b
<*> Constant a
a = b -> Constant n b
forall n a. a -> Constant n a
Constant (a -> b
f a
a)

instance (Tuple.Phi a) => Tuple.Phi (Constant n a) where
   phi :: forall r.
BasicBlock -> Constant n a -> CodeGenFunction r (Constant n a)
phi BasicBlock
bb (Constant a
a) = a -> Constant n a
forall n a. a -> Constant n a
Constant (a -> Constant n a)
-> CodeGenFunction r a -> CodeGenFunction r (Constant n a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BasicBlock -> a -> CodeGenFunction r a
forall a r. Phi a => BasicBlock -> a -> CodeGenFunction r a
forall r. BasicBlock -> a -> CodeGenFunction r a
Tuple.phi BasicBlock
bb a
a
   addPhi :: forall r.
BasicBlock -> Constant n a -> Constant n a -> CodeGenFunction r ()
addPhi BasicBlock
bb (Constant a
a) (Constant a
b) = BasicBlock -> a -> a -> CodeGenFunction r ()
forall a r. Phi a => BasicBlock -> a -> a -> CodeGenFunction r ()
forall r. BasicBlock -> a -> a -> CodeGenFunction r ()
Tuple.addPhi BasicBlock
bb a
a a
b

instance (Tuple.Undefined a) => Tuple.Undefined (Constant n a) where
   undef :: Constant n a
undef = Constant n a
forall a (f :: * -> *). (Undefined a, Applicative f) => f a
Tuple.undefPointed



instance (TypeNum.Positive n) => Sized (Constant n a) where
   type Size (Constant n a) = n

instance
   (TypeNum.Positive n, Tuple.Phi a, Tuple.Undefined a) =>
      Read (Constant n a) where

   type Element (Constant n a) = a
   type ReadIt (Constant n a) = a

   extract :: forall r.
Value Word32
-> Constant n a -> CodeGenFunction r (Element (Constant n a))
extract Value Word32
_k (Constant a
a) = a -> CodeGenFunction r a
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a

   readStart :: forall r.
Constant n a
-> CodeGenFunction
     r (ReadIterator (ReadIt (Constant n a)) (Constant n a))
readStart (Constant a
a) = ReadIterator (ReadIt (Constant n a)) (Constant n a)
-> CodeGenFunction
     r (ReadIterator (ReadIt (Constant n a)) (Constant n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ReadIterator (ReadIt (Constant n a)) (Constant n a)
 -> CodeGenFunction
      r (ReadIterator (ReadIt (Constant n a)) (Constant n a)))
-> ReadIterator (ReadIt (Constant n a)) (Constant n a)
-> CodeGenFunction
     r (ReadIterator (ReadIt (Constant n a)) (Constant n a))
forall a b. (a -> b) -> a -> b
$ a -> Iterator ReadMode a (Constant n a)
forall mode it v. it -> Iterator mode it v
Iterator a
a
   readNext :: forall r.
ReadIterator (ReadIt (Constant n a)) (Constant n a)
-> CodeGenFunction
     r
     (Element (Constant n a),
      ReadIterator (ReadIt (Constant n a)) (Constant n a))
readNext it :: ReadIterator (ReadIt (Constant n a)) (Constant n a)
it@(Iterator ReadIt (Constant n a)
a) = (a, Iterator ReadMode a (Constant n a))
-> CodeGenFunction r (a, Iterator ReadMode a (Constant n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
ReadIt (Constant n a)
a, Iterator ReadMode a (Constant n a)
ReadIterator (ReadIt (Constant n a)) (Constant n a)
it)



newtype Iterator mode it v = Iterator {forall mode it v. Iterator mode it v -> it
unIterator :: it}
   deriving (Iterator mode it v
Iterator mode it v -> Undefined (Iterator mode it v)
forall a. a -> Undefined a
forall mode it v. Undefined it => Iterator mode it v
$cundef :: forall mode it v. Undefined it => Iterator mode it v
undef :: Iterator mode it v
Tuple.Undefined)

instance Tuple.Phi it => Tuple.Phi (Iterator mode it v) where
   phi :: forall r.
BasicBlock
-> Iterator mode it v -> CodeGenFunction r (Iterator mode it v)
phi BasicBlock
bb (Iterator it
x) = (it -> Iterator mode it v)
-> CodeGenFunction r it -> CodeGenFunction r (Iterator mode it v)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap it -> Iterator mode it v
forall mode it v. it -> Iterator mode it v
Iterator (CodeGenFunction r it -> CodeGenFunction r (Iterator mode it v))
-> CodeGenFunction r it -> CodeGenFunction r (Iterator mode it v)
forall a b. (a -> b) -> a -> b
$ BasicBlock -> it -> CodeGenFunction r it
forall a r. Phi a => BasicBlock -> a -> CodeGenFunction r a
forall r. BasicBlock -> it -> CodeGenFunction r it
Tuple.phi BasicBlock
bb it
x
   addPhi :: forall r.
BasicBlock
-> Iterator mode it v -> Iterator mode it v -> CodeGenFunction r ()
addPhi BasicBlock
bb (Iterator it
x) (Iterator it
y) = BasicBlock -> it -> it -> CodeGenFunction r ()
forall a r. Phi a => BasicBlock -> a -> a -> CodeGenFunction r ()
forall r. BasicBlock -> it -> it -> CodeGenFunction r ()
Tuple.addPhi BasicBlock
bb it
x it
y


type ReadIterator = Iterator ReadMode
type WriteIterator = Iterator WriteMode

data ReadMode
data WriteMode


instance (Memory.C it) => Memory.C (Iterator mode it v) where
   type Struct (Iterator mode it v) = Memory.Struct it
   load :: forall r.
Value (Ptr (Struct (Iterator mode it v)))
-> CodeGenFunction r (Iterator mode it v)
load = (it -> Iterator mode it v)
-> Value (Ptr (Struct it))
-> CodeGenFunction r (Iterator mode it v)
forall a llvmValue r.
C a =>
(a -> llvmValue)
-> Value (Ptr (Struct a)) -> CodeGenFunction r llvmValue
Memory.loadNewtype it -> Iterator mode it v
forall mode it v. it -> Iterator mode it v
Iterator
   store :: forall r.
Iterator mode it v
-> Value (Ptr (Struct (Iterator mode it v)))
-> CodeGenFunction r ()
store = (Iterator mode it v -> it)
-> Iterator mode it v
-> Value (Ptr (Struct it))
-> CodeGenFunction r ()
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> Value (Ptr (Struct a)) -> CodeGenFunction r ()
Memory.storeNewtype (\(Iterator it
v) -> it
v)
   decompose :: forall r.
Value (Struct (Iterator mode it v))
-> CodeGenFunction r (Iterator mode it v)
decompose = (it -> Iterator mode it v)
-> Value (Struct it) -> CodeGenFunction r (Iterator mode it v)
forall a llvmValue r.
C a =>
(a -> llvmValue) -> Value (Struct a) -> CodeGenFunction r llvmValue
Memory.decomposeNewtype it -> Iterator mode it v
forall mode it v. it -> Iterator mode it v
Iterator
   compose :: forall r.
Iterator mode it v
-> CodeGenFunction r (Value (Struct (Iterator mode it v)))
compose = (Iterator mode it v -> it)
-> Iterator mode it v -> CodeGenFunction r (Value (Struct it))
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> CodeGenFunction r (Value (Struct a))
Memory.composeNewtype (\(Iterator it
v) -> it
v)


fmapIt ::
   (ita -> itb) -> (va -> vb) ->
   Iterator mode ita va -> Iterator mode itb vb
fmapIt :: forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt ita -> itb
f va -> vb
_ (Iterator ita
a) = itb -> Iterator mode itb vb
forall mode it v. it -> Iterator mode it v
Iterator (ita -> itb
f ita
a)


combineIt2 ::
   Iterator mode xa va -> Iterator mode xb vb ->
   Iterator mode (xa,xb) (va,vb)
combineIt2 :: forall mode xa va xb vb.
Iterator mode xa va
-> Iterator mode xb vb -> Iterator mode (xa, xb) (va, vb)
combineIt2 (Iterator xa
va) (Iterator xb
vb) = (xa, xb) -> Iterator mode (xa, xb) (va, vb)
forall mode it v. it -> Iterator mode it v
Iterator (xa
va,xb
vb)

combineIt3 ::
   Iterator mode xa va -> Iterator mode xb vb -> Iterator mode xc vc ->
   Iterator mode (xa,xb,xc) (va,vb,vc)
combineIt3 :: forall mode xa va xb vb xc vc.
Iterator mode xa va
-> Iterator mode xb vb
-> Iterator mode xc vc
-> Iterator mode (xa, xb, xc) (va, vb, vc)
combineIt3 (Iterator xa
va) (Iterator xb
vb) (Iterator xc
vc) = (xa, xb, xc) -> Iterator mode (xa, xb, xc) (va, vb, vc)
forall mode it v. it -> Iterator mode it v
Iterator (xa
va,xb
vb,xc
vc)

combineItFunctor ::
   (Functor f) => f (Iterator mode x v) -> Iterator mode (f x) (f v)
combineItFunctor :: forall (f :: * -> *) mode x v.
Functor f =>
f (Iterator mode x v) -> Iterator mode (f x) (f v)
combineItFunctor = f x -> Iterator mode (f x) (f v)
forall mode it v. it -> Iterator mode it v
Iterator (f x -> Iterator mode (f x) (f v))
-> (f (Iterator mode x v) -> f x)
-> f (Iterator mode x v)
-> Iterator mode (f x) (f v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Iterator mode x v -> x) -> f (Iterator mode x v) -> f x
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Iterator mode x v -> x
forall mode it v. Iterator mode it v -> it
unIterator

sequenceItFunctor ::
   (Functor f) => Iterator mode (f it) (f v) -> f (Iterator mode it v)
sequenceItFunctor :: forall (f :: * -> *) mode it v.
Functor f =>
Iterator mode (f it) (f v) -> f (Iterator mode it v)
sequenceItFunctor = (it -> Iterator mode it v) -> f it -> f (Iterator mode it v)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap it -> Iterator mode it v
forall mode it v. it -> Iterator mode it v
Iterator (f it -> f (Iterator mode it v))
-> (Iterator mode (f it) (f v) -> f it)
-> Iterator mode (f it) (f v)
-> f (Iterator mode it v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Iterator mode (f it) (f v) -> f it
forall mode it v. Iterator mode it v -> it
unIterator


withSize :: Sized v => (Int -> m v) -> m v
withSize :: forall v (m :: * -> *). Sized v => (Int -> m v) -> m v
withSize =
   let sz :: (Sized v) => TypeNum.Singleton (Size v) -> (Int -> m v) -> m v
       sz :: forall v (m :: * -> *).
Sized v =>
Singleton (Size v) -> (Int -> m v) -> m v
sz Singleton (Size v)
n Int -> m v
f = Int -> m v
f (Singleton (Size v) -> Int
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton (Size v)
n)
   in  Singleton (Size v) -> (Int -> m v) -> m v
forall v (m :: * -> *).
Sized v =>
Singleton (Size v) -> (Int -> m v) -> m v
sz Singleton (Size v)
forall x. Integer x => Singleton x
TypeNum.singleton

size :: (Sized v, Integral i) => v -> i
size :: forall v i. (Sized v, Integral i) => v -> i
size =
   let sz :: (Sized v, Integral i) => TypeNum.Singleton (Size v) -> v -> i
       sz :: forall v i. (Sized v, Integral i) => Singleton (Size v) -> v -> i
sz Singleton (Size v)
n v
_ = Singleton (Size v) -> i
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton (Size v)
n
   in  Singleton (Size v) -> v -> i
forall v i. (Sized v, Integral i) => Singleton (Size v) -> v -> i
sz Singleton (Size v)
forall x. Integer x => Singleton x
TypeNum.singleton

sizeOfIterator :: (Sized v, Integral i) => Iterator mode it v -> i
sizeOfIterator :: forall v i mode it.
(Sized v, Integral i) =>
Iterator mode it v -> i
sizeOfIterator =
   let sz :: (Sized v, Integral i) =>
               TypeNum.Singleton (Size v) -> Iterator mode it v -> i
       sz :: forall v i mode it.
(Sized v, Integral i) =>
Singleton (Size v) -> Iterator mode it v -> i
sz Singleton (Size v)
n Iterator mode it v
_ = Singleton (Size v) -> i
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton (Size v)
n
   in  Singleton (Size v) -> Iterator mode it v -> i
forall v i mode it.
(Sized v, Integral i) =>
Singleton (Size v) -> Iterator mode it v -> i
sz Singleton (Size v)
forall x. Integer x => Singleton x
TypeNum.singleton


{- |
The type parameter @v@ shall be a @MultiVector@ or @MultiValue Serial@
or a wrapper around one or more such things sharing the same size.
-}
class (TypeNum.Positive (Size v)) => Sized v where
   type Size v

class
   (Sized v,
    Tuple.Phi (ReadIt v), Tuple.Undefined (ReadIt v),
    Tuple.Phi v, Tuple.Undefined v) =>
      Read v where

   type Element v
   type ReadIt v

   extract :: LLVM.Value Word32 -> v -> LLVM.CodeGenFunction r (Element v)

   dissect :: v -> LLVM.CodeGenFunction r [Element v]
   dissect v
x = (Word32 -> CodeGenFunction r (Element v))
-> [Word32] -> CodeGenFunction r [Element v]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((Value Word32 -> v -> CodeGenFunction r (Element v))
-> v -> Value Word32 -> CodeGenFunction r (Element v)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract v
x (Value Word32 -> CodeGenFunction r (Element v))
-> (Word32 -> Value Word32)
-> Word32
-> CodeGenFunction r (Element v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf) (Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v i. (Sized v, Integral i) => v -> i
size v
x) [Word32
0..])

   readStart :: v -> LLVM.CodeGenFunction r (ReadIterator (ReadIt v) v)
   readNext ::
      ReadIterator (ReadIt v) v ->
      LLVM.CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)

class
   (Read v, Tuple.Phi (WriteIt v), Tuple.Undefined (WriteIt v)) =>
      Write v where
   type WriteIt v

   insert :: LLVM.Value Word32 -> Element v -> v -> LLVM.CodeGenFunction r v

   assemble :: [Element v] -> LLVM.CodeGenFunction r v
   assemble =
      (v -> (Word32, Element v) -> CodeGenFunction r v)
-> v -> [(Word32, Element v)] -> CodeGenFunction r v
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (\v
v (Word32
k,Element v
x) -> Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf Word32
k) Element v
x v
v) v
forall a. Undefined a => a
Tuple.undef ([(Word32, Element v)] -> CodeGenFunction r v)
-> ([Element v] -> [(Word32, Element v)])
-> [Element v]
-> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word32] -> [Element v] -> [(Word32, Element v)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Word32
0..]

   writeStart :: LLVM.CodeGenFunction r (WriteIterator (WriteIt v) v)
   writeNext ::
      Element v -> WriteIterator (WriteIt v) v ->
      LLVM.CodeGenFunction r (WriteIterator (WriteIt v) v)
   writeStop :: WriteIterator (WriteIt v) v -> LLVM.CodeGenFunction r v

class (Write v, Tuple.Phi (WriteIt v), Tuple.Zero (WriteIt v)) => Zero v where
   -- initializes the target with zeros
   -- you may only call 'writeStop' on the result of 'writeZero'
   writeZero :: LLVM.CodeGenFunction r (WriteIterator (WriteIt v) v)



instance (TypeNum.Positive n) => Sized (MultiVector.T n a) where
   type Size (MultiVector.T n a) = n

instance (TypeNum.Positive n, MultiVector.C a) => Read (MultiVector.T n a) where

   type Element (MultiVector.T n a) = MultiValue.T a
   type ReadIt (MultiVector.T n a) = MultiVector.T n a

   extract :: forall r.
Value Word32 -> T n a -> CodeGenFunction r (Element (T n a))
extract = Value Word32 -> T n a -> CodeGenFunction r (T a)
Value Word32 -> T n a -> CodeGenFunction r (Element (T n a))
forall a n r.
(C a, Positive n) =>
Value Word32 -> T n a -> CodeGenFunction r (T a)
forall n r.
Positive n =>
Value Word32 -> T n a -> CodeGenFunction r (T a)
MultiVector.extract

   readStart :: forall r.
T n a -> CodeGenFunction r (ReadIterator (ReadIt (T n a)) (T n a))
readStart T n a
v = ReadIterator (ReadIt (T n a)) (T n a)
-> CodeGenFunction r (ReadIterator (ReadIt (T n a)) (T n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ReadIterator (ReadIt (T n a)) (T n a)
 -> CodeGenFunction r (ReadIterator (ReadIt (T n a)) (T n a)))
-> ReadIterator (ReadIt (T n a)) (T n a)
-> CodeGenFunction r (ReadIterator (ReadIt (T n a)) (T n a))
forall a b. (a -> b) -> a -> b
$ T n a -> Iterator ReadMode (T n a) (T n a)
forall mode it v. it -> Iterator mode it v
Iterator T n a
v
   readNext :: forall r.
ReadIterator (ReadIt (T n a)) (T n a)
-> CodeGenFunction
     r (Element (T n a), ReadIterator (ReadIt (T n a)) (T n a))
readNext (Iterator ReadIt (T n a)
v) =
      (T n a -> Iterator ReadMode (T n a) (T n a))
-> (T a, T n a) -> (T a, Iterator ReadMode (T n a) (T n a))
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd T n a -> Iterator ReadMode (T n a) (T n a)
forall mode it v. it -> Iterator mode it v
Iterator ((T a, T n a) -> (T a, Iterator ReadMode (T n a) (T n a)))
-> CodeGenFunction r (T a, T n a)
-> CodeGenFunction r (T a, Iterator ReadMode (T n a) (T n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> T a -> T n a -> CodeGenFunction r (T a, T n a)
forall n a r.
(Positive n, C a) =>
T a -> T n a -> CodeGenFunction r (T a, T n a)
MultiVector.shiftDown T a
forall a. C a => T a
MultiValue.undef T n a
ReadIt (T n a)
v

instance
      (TypeNum.Positive n, MultiVector.C a) => Write (MultiVector.T n a) where

   type WriteIt (MultiVector.T n a) = MultiVector.T n a

   insert :: forall r.
Value Word32
-> Element (T n a) -> T n a -> CodeGenFunction r (T n a)
insert = Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
Value Word32
-> Element (T n a) -> T n a -> CodeGenFunction r (T n a)
forall a n r.
(C a, Positive n) =>
Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
MultiVector.insert

   writeStart :: forall r.
CodeGenFunction r (WriteIterator (WriteIt (T n a)) (T n a))
writeStart = Iterator WriteMode (T n a) (T n a)
-> CodeGenFunction r (Iterator WriteMode (T n a) (T n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (T n a -> Iterator WriteMode (T n a) (T n a)
forall mode it v. it -> Iterator mode it v
Iterator T n a
forall a n. (C a, Positive n) => T n a
forall n. Positive n => T n a
MultiVector.undef)
   writeNext :: forall r.
Element (T n a)
-> WriteIterator (WriteIt (T n a)) (T n a)
-> CodeGenFunction r (WriteIterator (WriteIt (T n a)) (T n a))
writeNext Element (T n a)
x (Iterator WriteIt (T n a)
v) = T n a -> Iterator WriteMode (T n a) (T n a)
forall mode it v. it -> Iterator mode it v
Iterator (T n a -> Iterator WriteMode (T n a) (T n a))
-> ((T a, T n a) -> T n a)
-> (T a, T n a)
-> Iterator WriteMode (T n a) (T n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a, T n a) -> T n a
forall a b. (a, b) -> b
snd ((T a, T n a) -> Iterator WriteMode (T n a) (T n a))
-> CodeGenFunction r (T a, T n a)
-> CodeGenFunction r (Iterator WriteMode (T n a) (T n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> T a -> T n a -> CodeGenFunction r (T a, T n a)
forall n a r.
(Positive n, C a) =>
T a -> T n a -> CodeGenFunction r (T a, T n a)
MultiVector.shiftDown T a
Element (T n a)
x T n a
WriteIt (T n a)
v
   writeStop :: forall r.
WriteIterator (WriteIt (T n a)) (T n a)
-> CodeGenFunction r (T n a)
writeStop (Iterator WriteIt (T n a)
v) = T n a -> CodeGenFunction r (T n a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return T n a
WriteIt (T n a)
v

instance (TypeNum.Positive n, MultiVector.C a) => Zero (MultiVector.T n a) where
   writeZero :: forall r.
CodeGenFunction r (WriteIterator (WriteIt (T n a)) (T n a))
writeZero = Iterator WriteMode (T n a) (T n a)
-> CodeGenFunction r (Iterator WriteMode (T n a) (T n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (T n a -> Iterator WriteMode (T n a) (T n a)
forall mode it v. it -> Iterator mode it v
Iterator T n a
forall a. Zero a => a
Tuple.zero)



type Serial n a = SerialCode.Value n a

instance (TypeNum.Positive n) => Sized (Serial n a) where
   type Size (Serial n a) = n

instance (TypeNum.Positive n, MultiVector.C a) => Read (Serial n a) where

   type Element (Serial n a) = MultiValue.T a
   type ReadIt (Serial n a) = Serial n a

   extract :: forall r.
Value Word32
-> Serial n a -> CodeGenFunction r (Element (Serial n a))
extract = Value Word32 -> Serial n a -> CodeGenFunction r (T a)
Value Word32
-> Serial n a -> CodeGenFunction r (Element (Serial n a))
forall n x a v r.
(Positive n, C x, T x ~ a, Value n x ~ v) =>
Value Word32 -> v -> CodeGenFunction r a
SerialCode.extract

   readStart :: forall r.
Serial n a
-> CodeGenFunction
     r (ReadIterator (ReadIt (Serial n a)) (Serial n a))
readStart Serial n a
v = ReadIterator (ReadIt (Serial n a)) (Serial n a)
-> CodeGenFunction
     r (ReadIterator (ReadIt (Serial n a)) (Serial n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ReadIterator (ReadIt (Serial n a)) (Serial n a)
 -> CodeGenFunction
      r (ReadIterator (ReadIt (Serial n a)) (Serial n a)))
-> ReadIterator (ReadIt (Serial n a)) (Serial n a)
-> CodeGenFunction
     r (ReadIterator (ReadIt (Serial n a)) (Serial n a))
forall a b. (a -> b) -> a -> b
$ Serial n a -> Iterator ReadMode (Serial n a) (Serial n a)
forall mode it v. it -> Iterator mode it v
Iterator Serial n a
v
   readNext :: forall r.
ReadIterator (ReadIt (Serial n a)) (Serial n a)
-> CodeGenFunction
     r
     (Element (Serial n a),
      ReadIterator (ReadIt (Serial n a)) (Serial n a))
readNext (Iterator ReadIt (Serial n a)
v) =
      (Serial n a -> Iterator ReadMode (Serial n a) (Serial n a))
-> (T a, Serial n a)
-> (T a, Iterator ReadMode (Serial n a) (Serial n a))
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd Serial n a -> Iterator ReadMode (Serial n a) (Serial n a)
forall mode it v. it -> Iterator mode it v
Iterator ((T a, Serial n a)
 -> (T a, Iterator ReadMode (Serial n a) (Serial n a)))
-> CodeGenFunction r (T a, Serial n a)
-> CodeGenFunction
     r (T a, Iterator ReadMode (Serial n a) (Serial n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> T a -> Serial n a -> CodeGenFunction r (T a, Serial n a)
forall n x a v r.
(Positive n, C x, T x ~ a, Value n x ~ v) =>
a -> v -> CodeGenFunction r (a, v)
SerialCode.shiftDown T a
forall a. C a => T a
MultiValue.undef Serial n a
ReadIt (Serial n a)
v

instance (TypeNum.Positive n, MultiVector.C a) => Write (Serial n a) where

   type WriteIt (Serial n a) = Serial n a

   insert :: forall r.
Value Word32
-> Element (Serial n a)
-> Serial n a
-> CodeGenFunction r (Serial n a)
insert = Value Word32 -> T a -> Serial n a -> CodeGenFunction r (Serial n a)
Value Word32
-> Element (Serial n a)
-> Serial n a
-> CodeGenFunction r (Serial n a)
forall n x a v r.
(Positive n, C x, T x ~ a, Value n x ~ v) =>
Value Word32 -> a -> v -> CodeGenFunction r v
SerialCode.insert

   writeStart :: forall r.
CodeGenFunction
  r (WriteIterator (WriteIt (Serial n a)) (Serial n a))
writeStart = Iterator WriteMode (Serial n a) (Serial n a)
-> CodeGenFunction r (Iterator WriteMode (Serial n a) (Serial n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Serial n a -> Iterator WriteMode (Serial n a) (Serial n a)
forall mode it v. it -> Iterator mode it v
Iterator Serial n a
forall a. Undefined a => a
Tuple.undef)
   writeNext :: forall r.
Element (Serial n a)
-> WriteIterator (WriteIt (Serial n a)) (Serial n a)
-> CodeGenFunction
     r (WriteIterator (WriteIt (Serial n a)) (Serial n a))
writeNext Element (Serial n a)
x (Iterator WriteIt (Serial n a)
v) = Serial n a -> Iterator WriteMode (Serial n a) (Serial n a)
forall mode it v. it -> Iterator mode it v
Iterator (Serial n a -> Iterator WriteMode (Serial n a) (Serial n a))
-> ((T a, Serial n a) -> Serial n a)
-> (T a, Serial n a)
-> Iterator WriteMode (Serial n a) (Serial n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a, Serial n a) -> Serial n a
forall a b. (a, b) -> b
snd ((T a, Serial n a) -> Iterator WriteMode (Serial n a) (Serial n a))
-> CodeGenFunction r (T a, Serial n a)
-> CodeGenFunction r (Iterator WriteMode (Serial n a) (Serial n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> T a -> Serial n a -> CodeGenFunction r (T a, Serial n a)
forall n x a v r.
(Positive n, C x, T x ~ a, Value n x ~ v) =>
a -> v -> CodeGenFunction r (a, v)
SerialCode.shiftDown T a
Element (Serial n a)
x Serial n a
WriteIt (Serial n a)
v
   writeStop :: forall r.
WriteIterator (WriteIt (Serial n a)) (Serial n a)
-> CodeGenFunction r (Serial n a)
writeStop (Iterator WriteIt (Serial n a)
v) = Serial n a -> CodeGenFunction r (Serial n a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return Serial n a
WriteIt (Serial n a)
v

instance (TypeNum.Positive n, MultiVector.C a) => Zero (Serial n a) where
   writeZero :: forall r.
CodeGenFunction
  r (WriteIterator (WriteIt (Serial n a)) (Serial n a))
writeZero = Iterator WriteMode (Serial n a) (Serial n a)
-> CodeGenFunction r (Iterator WriteMode (Serial n a) (Serial n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Serial n a -> Iterator WriteMode (Serial n a) (Serial n a)
forall mode it v. it -> Iterator mode it v
Iterator Serial n a
forall a. Zero a => a
Tuple.zero)



instance (Sized va, Sized vb, Size va ~ Size vb) => Sized (va, vb) where
   type Size (va, vb) = Size va

instance (Read va, Read vb, Size va ~ Size vb) => Read (va, vb) where

   type Element (va, vb) = (Element va, Element vb)
   type ReadIt (va, vb) = (ReadIt va, ReadIt vb)

   extract :: forall r.
Value Word32 -> (va, vb) -> CodeGenFunction r (Element (va, vb))
extract Value Word32
k (va
va,vb
vb) = (Element va -> Element vb -> (Element va, Element vb))
-> CodeGenFunction r (Element va)
-> CodeGenFunction r (Element vb)
-> CodeGenFunction r (Element va, Element vb)
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,) (Value Word32 -> va -> CodeGenFunction r (Element va)
forall r. Value Word32 -> va -> CodeGenFunction r (Element va)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k va
va) (Value Word32 -> vb -> CodeGenFunction r (Element vb)
forall r. Value Word32 -> vb -> CodeGenFunction r (Element vb)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k vb
vb)

   readStart :: forall r.
(va, vb)
-> CodeGenFunction r (ReadIterator (ReadIt (va, vb)) (va, vb))
readStart (va
va,vb
vb) = (Iterator ReadMode (ReadIt va) va
 -> Iterator ReadMode (ReadIt vb) vb
 -> Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb))
-> CodeGenFunction r (Iterator ReadMode (ReadIt va) va)
-> CodeGenFunction r (Iterator ReadMode (ReadIt vb) vb)
-> CodeGenFunction
     r (Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb))
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Iterator ReadMode (ReadIt va) va
-> Iterator ReadMode (ReadIt vb) vb
-> Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb)
forall mode xa va xb vb.
Iterator mode xa va
-> Iterator mode xb vb -> Iterator mode (xa, xb) (va, vb)
combineIt2 (va -> CodeGenFunction r (Iterator ReadMode (ReadIt va) va)
forall r.
va -> CodeGenFunction r (Iterator ReadMode (ReadIt va) va)
forall v r.
Read v =>
v -> CodeGenFunction r (ReadIterator (ReadIt v) v)
readStart va
va) (vb -> CodeGenFunction r (Iterator ReadMode (ReadIt vb) vb)
forall r.
vb -> CodeGenFunction r (Iterator ReadMode (ReadIt vb) vb)
forall v r.
Read v =>
v -> CodeGenFunction r (ReadIterator (ReadIt v) v)
readStart vb
vb)
   readNext :: forall r.
ReadIterator (ReadIt (va, vb)) (va, vb)
-> CodeGenFunction
     r (Element (va, vb), ReadIterator (ReadIt (va, vb)) (va, vb))
readNext ReadIterator (ReadIt (va, vb)) (va, vb)
it = do
      (Element va
a, Iterator ReadMode (ReadIt va) va
ita) <- Iterator ReadMode (ReadIt va) va
-> CodeGenFunction r (Element va, Iterator ReadMode (ReadIt va) va)
forall v r.
Read v =>
ReadIterator (ReadIt v) v
-> CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)
forall r.
Iterator ReadMode (ReadIt va) va
-> CodeGenFunction r (Element va, Iterator ReadMode (ReadIt va) va)
readNext (Iterator ReadMode (ReadIt va) va
 -> CodeGenFunction
      r (Element va, Iterator ReadMode (ReadIt va) va))
-> Iterator ReadMode (ReadIt va) va
-> CodeGenFunction r (Element va, Iterator ReadMode (ReadIt va) va)
forall a b. (a -> b) -> a -> b
$ ((ReadIt va, ReadIt vb) -> ReadIt va)
-> ((va, vb) -> va)
-> Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb)
-> Iterator ReadMode (ReadIt va) va
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (ReadIt va, ReadIt vb) -> ReadIt va
forall a b. (a, b) -> a
fst (va, vb) -> va
forall a b. (a, b) -> a
fst Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb)
ReadIterator (ReadIt (va, vb)) (va, vb)
it
      (Element vb
b, Iterator ReadMode (ReadIt vb) vb
itb) <- Iterator ReadMode (ReadIt vb) vb
-> CodeGenFunction r (Element vb, Iterator ReadMode (ReadIt vb) vb)
forall v r.
Read v =>
ReadIterator (ReadIt v) v
-> CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)
forall r.
Iterator ReadMode (ReadIt vb) vb
-> CodeGenFunction r (Element vb, Iterator ReadMode (ReadIt vb) vb)
readNext (Iterator ReadMode (ReadIt vb) vb
 -> CodeGenFunction
      r (Element vb, Iterator ReadMode (ReadIt vb) vb))
-> Iterator ReadMode (ReadIt vb) vb
-> CodeGenFunction r (Element vb, Iterator ReadMode (ReadIt vb) vb)
forall a b. (a -> b) -> a -> b
$ ((ReadIt va, ReadIt vb) -> ReadIt vb)
-> ((va, vb) -> vb)
-> Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb)
-> Iterator ReadMode (ReadIt vb) vb
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (ReadIt va, ReadIt vb) -> ReadIt vb
forall a b. (a, b) -> b
snd (va, vb) -> vb
forall a b. (a, b) -> b
snd Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb)
ReadIterator (ReadIt (va, vb)) (va, vb)
it
      ((Element va, Element vb),
 Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb))
-> CodeGenFunction
     r
     ((Element va, Element vb),
      Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Element va
a,Element vb
b), Iterator ReadMode (ReadIt va) va
-> Iterator ReadMode (ReadIt vb) vb
-> Iterator ReadMode (ReadIt va, ReadIt vb) (va, vb)
forall mode xa va xb vb.
Iterator mode xa va
-> Iterator mode xb vb -> Iterator mode (xa, xb) (va, vb)
combineIt2 Iterator ReadMode (ReadIt va) va
ita Iterator ReadMode (ReadIt vb) vb
itb)

instance (Write va, Write vb, Size va ~ Size vb) => Write (va, vb) where

   type WriteIt (va, vb) = (WriteIt va, WriteIt vb)

   insert :: forall r.
Value Word32
-> Element (va, vb) -> (va, vb) -> CodeGenFunction r (va, vb)
insert Value Word32
k (Element va
a,Element vb
b) (va
va,vb
vb) =
      (va -> vb -> (va, vb))
-> CodeGenFunction r va
-> CodeGenFunction r vb
-> CodeGenFunction r (va, vb)
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,)
         (Value Word32 -> Element va -> va -> CodeGenFunction r va
forall r. Value Word32 -> Element va -> va -> CodeGenFunction r va
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element va
a va
va)
         (Value Word32 -> Element vb -> vb -> CodeGenFunction r vb
forall r. Value Word32 -> Element vb -> vb -> CodeGenFunction r vb
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element vb
b vb
vb)

   writeStart :: forall r.
CodeGenFunction r (WriteIterator (WriteIt (va, vb)) (va, vb))
writeStart = (Iterator WriteMode (WriteIt va) va
 -> Iterator WriteMode (WriteIt vb) vb
 -> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb))
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
-> CodeGenFunction
     r (Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb))
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Iterator WriteMode (WriteIt va) va
-> Iterator WriteMode (WriteIt vb) vb
-> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
forall mode xa va xb vb.
Iterator mode xa va
-> Iterator mode xb vb -> Iterator mode (xa, xb) (va, vb)
combineIt2 CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall v r.
Write v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeStart CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall v r.
Write v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeStart
   writeNext :: forall r.
Element (va, vb)
-> WriteIterator (WriteIt (va, vb)) (va, vb)
-> CodeGenFunction r (WriteIterator (WriteIt (va, vb)) (va, vb))
writeNext (Element va
a,Element vb
b) WriteIterator (WriteIt (va, vb)) (va, vb)
it =
      (Iterator WriteMode (WriteIt va) va
 -> Iterator WriteMode (WriteIt vb) vb
 -> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb))
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
-> CodeGenFunction
     r (Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb))
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Iterator WriteMode (WriteIt va) va
-> Iterator WriteMode (WriteIt vb) vb
-> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
forall mode xa va xb vb.
Iterator mode xa va
-> Iterator mode xb vb -> Iterator mode (xa, xb) (va, vb)
combineIt2
         (Element va
-> Iterator WriteMode (WriteIt va) va
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall v r.
Write v =>
Element v
-> WriteIterator (WriteIt v) v
-> CodeGenFunction r (WriteIterator (WriteIt v) v)
forall r.
Element va
-> Iterator WriteMode (WriteIt va) va
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
writeNext Element va
a (Iterator WriteMode (WriteIt va) va
 -> CodeGenFunction r (Iterator WriteMode (WriteIt va) va))
-> Iterator WriteMode (WriteIt va) va
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall a b. (a -> b) -> a -> b
$ ((WriteIt va, WriteIt vb) -> WriteIt va)
-> ((va, vb) -> va)
-> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
-> Iterator WriteMode (WriteIt va) va
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb) -> WriteIt va
forall a b. (a, b) -> a
fst (va, vb) -> va
forall a b. (a, b) -> a
fst Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
WriteIterator (WriteIt (va, vb)) (va, vb)
it)
         (Element vb
-> Iterator WriteMode (WriteIt vb) vb
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall v r.
Write v =>
Element v
-> WriteIterator (WriteIt v) v
-> CodeGenFunction r (WriteIterator (WriteIt v) v)
forall r.
Element vb
-> Iterator WriteMode (WriteIt vb) vb
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
writeNext Element vb
b (Iterator WriteMode (WriteIt vb) vb
 -> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb))
-> Iterator WriteMode (WriteIt vb) vb
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall a b. (a -> b) -> a -> b
$ ((WriteIt va, WriteIt vb) -> WriteIt vb)
-> ((va, vb) -> vb)
-> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
-> Iterator WriteMode (WriteIt vb) vb
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb) -> WriteIt vb
forall a b. (a, b) -> b
snd (va, vb) -> vb
forall a b. (a, b) -> b
snd Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
WriteIterator (WriteIt (va, vb)) (va, vb)
it)
   writeStop :: forall r.
WriteIterator (WriteIt (va, vb)) (va, vb)
-> CodeGenFunction r (va, vb)
writeStop WriteIterator (WriteIt (va, vb)) (va, vb)
it =
      (va -> vb -> (va, vb))
-> CodeGenFunction r va
-> CodeGenFunction r vb
-> CodeGenFunction r (va, vb)
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,)
         (Iterator WriteMode (WriteIt va) va -> CodeGenFunction r va
forall v r.
Write v =>
WriteIterator (WriteIt v) v -> CodeGenFunction r v
forall r.
Iterator WriteMode (WriteIt va) va -> CodeGenFunction r va
writeStop (((WriteIt va, WriteIt vb) -> WriteIt va)
-> ((va, vb) -> va)
-> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
-> Iterator WriteMode (WriteIt va) va
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb) -> WriteIt va
forall a b. (a, b) -> a
fst (va, vb) -> va
forall a b. (a, b) -> a
fst Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
WriteIterator (WriteIt (va, vb)) (va, vb)
it))
         (Iterator WriteMode (WriteIt vb) vb -> CodeGenFunction r vb
forall v r.
Write v =>
WriteIterator (WriteIt v) v -> CodeGenFunction r v
forall r.
Iterator WriteMode (WriteIt vb) vb -> CodeGenFunction r vb
writeStop (((WriteIt va, WriteIt vb) -> WriteIt vb)
-> ((va, vb) -> vb)
-> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
-> Iterator WriteMode (WriteIt vb) vb
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb) -> WriteIt vb
forall a b. (a, b) -> b
snd (va, vb) -> vb
forall a b. (a, b) -> b
snd Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
WriteIterator (WriteIt (va, vb)) (va, vb)
it))

instance (Zero va, Zero vb, Size va ~ Size vb) => Zero (va, vb) where
   writeZero :: forall r.
CodeGenFunction r (WriteIterator (WriteIt (va, vb)) (va, vb))
writeZero = (Iterator WriteMode (WriteIt va) va
 -> Iterator WriteMode (WriteIt vb) vb
 -> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb))
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
-> CodeGenFunction
     r (Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb))
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Iterator WriteMode (WriteIt va) va
-> Iterator WriteMode (WriteIt vb) vb
-> Iterator WriteMode (WriteIt va, WriteIt vb) (va, vb)
forall mode xa va xb vb.
Iterator mode xa va
-> Iterator mode xb vb -> Iterator mode (xa, xb) (va, vb)
combineIt2 CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall v r.
Zero v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeZero CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall v r.
Zero v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeZero


instance
   (Sized va, Sized vb, Sized vc, Size va ~ Size vb, Size vb ~ Size vc) =>
      Sized (va, vb, vc) where
   type Size (va, vb, vc) = Size va

instance
   (Read va, Read vb, Read vc, Size va ~ Size vb, Size vb ~ Size vc) =>
      Read (va, vb, vc) where

   type Element (va, vb, vc) = (Element va, Element vb, Element vc)
   type ReadIt (va, vb, vc) = (ReadIt va, ReadIt vb, ReadIt vc)

   extract :: forall r.
Value Word32
-> (va, vb, vc) -> CodeGenFunction r (Element (va, vb, vc))
extract Value Word32
k (va
va,vb
vb,vc
vc) =
      (Element va
 -> Element vb
 -> Element vc
 -> (Element va, Element vb, Element vc))
-> CodeGenFunction r (Element va)
-> CodeGenFunction r (Element vb)
-> CodeGenFunction r (Element vc)
-> CodeGenFunction r (Element va, Element vb, Element vc)
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 (,,)
         (Value Word32 -> va -> CodeGenFunction r (Element va)
forall r. Value Word32 -> va -> CodeGenFunction r (Element va)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k va
va)
         (Value Word32 -> vb -> CodeGenFunction r (Element vb)
forall r. Value Word32 -> vb -> CodeGenFunction r (Element vb)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k vb
vb)
         (Value Word32 -> vc -> CodeGenFunction r (Element vc)
forall r. Value Word32 -> vc -> CodeGenFunction r (Element vc)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k vc
vc)

   readStart :: forall r.
(va, vb, vc)
-> CodeGenFunction
     r (ReadIterator (ReadIt (va, vb, vc)) (va, vb, vc))
readStart (va
va,vb
vb,vc
vc) =
      (Iterator ReadMode (ReadIt va) va
 -> Iterator ReadMode (ReadIt vb) vb
 -> Iterator ReadMode (ReadIt vc) vc
 -> Iterator
      ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc))
-> CodeGenFunction r (Iterator ReadMode (ReadIt va) va)
-> CodeGenFunction r (Iterator ReadMode (ReadIt vb) vb)
-> CodeGenFunction r (Iterator ReadMode (ReadIt vc) vc)
-> CodeGenFunction
     r
     (Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc))
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 Iterator ReadMode (ReadIt va) va
-> Iterator ReadMode (ReadIt vb) vb
-> Iterator ReadMode (ReadIt vc) vc
-> Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
forall mode xa va xb vb xc vc.
Iterator mode xa va
-> Iterator mode xb vb
-> Iterator mode xc vc
-> Iterator mode (xa, xb, xc) (va, vb, vc)
combineIt3 (va -> CodeGenFunction r (Iterator ReadMode (ReadIt va) va)
forall r.
va -> CodeGenFunction r (Iterator ReadMode (ReadIt va) va)
forall v r.
Read v =>
v -> CodeGenFunction r (ReadIterator (ReadIt v) v)
readStart va
va) (vb -> CodeGenFunction r (Iterator ReadMode (ReadIt vb) vb)
forall r.
vb -> CodeGenFunction r (Iterator ReadMode (ReadIt vb) vb)
forall v r.
Read v =>
v -> CodeGenFunction r (ReadIterator (ReadIt v) v)
readStart vb
vb) (vc -> CodeGenFunction r (Iterator ReadMode (ReadIt vc) vc)
forall r.
vc -> CodeGenFunction r (Iterator ReadMode (ReadIt vc) vc)
forall v r.
Read v =>
v -> CodeGenFunction r (ReadIterator (ReadIt v) v)
readStart vc
vc)
   readNext :: forall r.
ReadIterator (ReadIt (va, vb, vc)) (va, vb, vc)
-> CodeGenFunction
     r
     (Element (va, vb, vc),
      ReadIterator (ReadIt (va, vb, vc)) (va, vb, vc))
readNext ReadIterator (ReadIt (va, vb, vc)) (va, vb, vc)
it = do
      (Element va
a, Iterator ReadMode (ReadIt va) va
ita) <- Iterator ReadMode (ReadIt va) va
-> CodeGenFunction r (Element va, Iterator ReadMode (ReadIt va) va)
forall v r.
Read v =>
ReadIterator (ReadIt v) v
-> CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)
forall r.
Iterator ReadMode (ReadIt va) va
-> CodeGenFunction r (Element va, Iterator ReadMode (ReadIt va) va)
readNext (Iterator ReadMode (ReadIt va) va
 -> CodeGenFunction
      r (Element va, Iterator ReadMode (ReadIt va) va))
-> Iterator ReadMode (ReadIt va) va
-> CodeGenFunction r (Element va, Iterator ReadMode (ReadIt va) va)
forall a b. (a -> b) -> a -> b
$ ((ReadIt va, ReadIt vb, ReadIt vc) -> ReadIt va)
-> ((va, vb, vc) -> va)
-> Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
-> Iterator ReadMode (ReadIt va) va
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (ReadIt va, ReadIt vb, ReadIt vc) -> ReadIt va
forall a b c. (a, b, c) -> a
fst3 (va, vb, vc) -> va
forall a b c. (a, b, c) -> a
fst3 Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
ReadIterator (ReadIt (va, vb, vc)) (va, vb, vc)
it
      (Element vb
b, Iterator ReadMode (ReadIt vb) vb
itb) <- Iterator ReadMode (ReadIt vb) vb
-> CodeGenFunction r (Element vb, Iterator ReadMode (ReadIt vb) vb)
forall v r.
Read v =>
ReadIterator (ReadIt v) v
-> CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)
forall r.
Iterator ReadMode (ReadIt vb) vb
-> CodeGenFunction r (Element vb, Iterator ReadMode (ReadIt vb) vb)
readNext (Iterator ReadMode (ReadIt vb) vb
 -> CodeGenFunction
      r (Element vb, Iterator ReadMode (ReadIt vb) vb))
-> Iterator ReadMode (ReadIt vb) vb
-> CodeGenFunction r (Element vb, Iterator ReadMode (ReadIt vb) vb)
forall a b. (a -> b) -> a -> b
$ ((ReadIt va, ReadIt vb, ReadIt vc) -> ReadIt vb)
-> ((va, vb, vc) -> vb)
-> Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
-> Iterator ReadMode (ReadIt vb) vb
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (ReadIt va, ReadIt vb, ReadIt vc) -> ReadIt vb
forall a b c. (a, b, c) -> b
snd3 (va, vb, vc) -> vb
forall a b c. (a, b, c) -> b
snd3 Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
ReadIterator (ReadIt (va, vb, vc)) (va, vb, vc)
it
      (Element vc
c, Iterator ReadMode (ReadIt vc) vc
itc) <- Iterator ReadMode (ReadIt vc) vc
-> CodeGenFunction r (Element vc, Iterator ReadMode (ReadIt vc) vc)
forall v r.
Read v =>
ReadIterator (ReadIt v) v
-> CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)
forall r.
Iterator ReadMode (ReadIt vc) vc
-> CodeGenFunction r (Element vc, Iterator ReadMode (ReadIt vc) vc)
readNext (Iterator ReadMode (ReadIt vc) vc
 -> CodeGenFunction
      r (Element vc, Iterator ReadMode (ReadIt vc) vc))
-> Iterator ReadMode (ReadIt vc) vc
-> CodeGenFunction r (Element vc, Iterator ReadMode (ReadIt vc) vc)
forall a b. (a -> b) -> a -> b
$ ((ReadIt va, ReadIt vb, ReadIt vc) -> ReadIt vc)
-> ((va, vb, vc) -> vc)
-> Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
-> Iterator ReadMode (ReadIt vc) vc
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (ReadIt va, ReadIt vb, ReadIt vc) -> ReadIt vc
forall a b c. (a, b, c) -> c
thd3 (va, vb, vc) -> vc
forall a b c. (a, b, c) -> c
thd3 Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
ReadIterator (ReadIt (va, vb, vc)) (va, vb, vc)
it
      ((Element va, Element vb, Element vc),
 Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc))
-> CodeGenFunction
     r
     ((Element va, Element vb, Element vc),
      Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Element va
a,Element vb
b,Element vc
c), Iterator ReadMode (ReadIt va) va
-> Iterator ReadMode (ReadIt vb) vb
-> Iterator ReadMode (ReadIt vc) vc
-> Iterator ReadMode (ReadIt va, ReadIt vb, ReadIt vc) (va, vb, vc)
forall mode xa va xb vb xc vc.
Iterator mode xa va
-> Iterator mode xb vb
-> Iterator mode xc vc
-> Iterator mode (xa, xb, xc) (va, vb, vc)
combineIt3 Iterator ReadMode (ReadIt va) va
ita Iterator ReadMode (ReadIt vb) vb
itb Iterator ReadMode (ReadIt vc) vc
itc)


instance
   (Write va, Write vb, Write vc, Size va ~ Size vb, Size vb ~ Size vc) =>
      Write (va, vb, vc) where

   type WriteIt (va, vb, vc) = (WriteIt va, WriteIt vb, WriteIt vc)

   insert :: forall r.
Value Word32
-> Element (va, vb, vc)
-> (va, vb, vc)
-> CodeGenFunction r (va, vb, vc)
insert Value Word32
k (Element va
a,Element vb
b,Element vc
c) (va
va,vb
vb,vc
vc) =
      (va -> vb -> vc -> (va, vb, vc))
-> CodeGenFunction r va
-> CodeGenFunction r vb
-> CodeGenFunction r vc
-> CodeGenFunction r (va, vb, vc)
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 (,,)
         (Value Word32 -> Element va -> va -> CodeGenFunction r va
forall r. Value Word32 -> Element va -> va -> CodeGenFunction r va
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element va
a va
va)
         (Value Word32 -> Element vb -> vb -> CodeGenFunction r vb
forall r. Value Word32 -> Element vb -> vb -> CodeGenFunction r vb
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element vb
b vb
vb)
         (Value Word32 -> Element vc -> vc -> CodeGenFunction r vc
forall r. Value Word32 -> Element vc -> vc -> CodeGenFunction r vc
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element vc
c vc
vc)

   writeStart :: forall r.
CodeGenFunction
  r (WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc))
writeStart = (Iterator WriteMode (WriteIt va) va
 -> Iterator WriteMode (WriteIt vb) vb
 -> Iterator WriteMode (WriteIt vc) vc
 -> Iterator
      WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc))
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
-> CodeGenFunction
     r
     (Iterator
        WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc))
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 Iterator WriteMode (WriteIt va) va
-> Iterator WriteMode (WriteIt vb) vb
-> Iterator WriteMode (WriteIt vc) vc
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
forall mode xa va xb vb xc vc.
Iterator mode xa va
-> Iterator mode xb vb
-> Iterator mode xc vc
-> Iterator mode (xa, xb, xc) (va, vb, vc)
combineIt3 CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall v r.
Write v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeStart CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall v r.
Write v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeStart CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
forall v r.
Write v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeStart
   writeNext :: forall r.
Element (va, vb, vc)
-> WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
-> CodeGenFunction
     r (WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc))
writeNext (Element va
a,Element vb
b,Element vc
c) WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it =
      (Iterator WriteMode (WriteIt va) va
 -> Iterator WriteMode (WriteIt vb) vb
 -> Iterator WriteMode (WriteIt vc) vc
 -> Iterator
      WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc))
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
-> CodeGenFunction
     r
     (Iterator
        WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc))
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 Iterator WriteMode (WriteIt va) va
-> Iterator WriteMode (WriteIt vb) vb
-> Iterator WriteMode (WriteIt vc) vc
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
forall mode xa va xb vb xc vc.
Iterator mode xa va
-> Iterator mode xb vb
-> Iterator mode xc vc
-> Iterator mode (xa, xb, xc) (va, vb, vc)
combineIt3
         (Element va
-> Iterator WriteMode (WriteIt va) va
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall v r.
Write v =>
Element v
-> WriteIterator (WriteIt v) v
-> CodeGenFunction r (WriteIterator (WriteIt v) v)
forall r.
Element va
-> Iterator WriteMode (WriteIt va) va
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
writeNext Element va
a (Iterator WriteMode (WriteIt va) va
 -> CodeGenFunction r (Iterator WriteMode (WriteIt va) va))
-> Iterator WriteMode (WriteIt va) va
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall a b. (a -> b) -> a -> b
$ ((WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt va)
-> ((va, vb, vc) -> va)
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
-> Iterator WriteMode (WriteIt va) va
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt va
forall a b c. (a, b, c) -> a
fst3 (va, vb, vc) -> va
forall a b c. (a, b, c) -> a
fst3 Iterator
  WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it)
         (Element vb
-> Iterator WriteMode (WriteIt vb) vb
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall v r.
Write v =>
Element v
-> WriteIterator (WriteIt v) v
-> CodeGenFunction r (WriteIterator (WriteIt v) v)
forall r.
Element vb
-> Iterator WriteMode (WriteIt vb) vb
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
writeNext Element vb
b (Iterator WriteMode (WriteIt vb) vb
 -> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb))
-> Iterator WriteMode (WriteIt vb) vb
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall a b. (a -> b) -> a -> b
$ ((WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vb)
-> ((va, vb, vc) -> vb)
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
-> Iterator WriteMode (WriteIt vb) vb
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vb
forall a b c. (a, b, c) -> b
snd3 (va, vb, vc) -> vb
forall a b c. (a, b, c) -> b
snd3 Iterator
  WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it)
         (Element vc
-> Iterator WriteMode (WriteIt vc) vc
-> CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
forall v r.
Write v =>
Element v
-> WriteIterator (WriteIt v) v
-> CodeGenFunction r (WriteIterator (WriteIt v) v)
forall r.
Element vc
-> Iterator WriteMode (WriteIt vc) vc
-> CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
writeNext Element vc
c (Iterator WriteMode (WriteIt vc) vc
 -> CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc))
-> Iterator WriteMode (WriteIt vc) vc
-> CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
forall a b. (a -> b) -> a -> b
$ ((WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vc)
-> ((va, vb, vc) -> vc)
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
-> Iterator WriteMode (WriteIt vc) vc
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vc
forall a b c. (a, b, c) -> c
thd3 (va, vb, vc) -> vc
forall a b c. (a, b, c) -> c
thd3 Iterator
  WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it)
   writeStop :: forall r.
WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
-> CodeGenFunction r (va, vb, vc)
writeStop WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it =
      (va -> vb -> vc -> (va, vb, vc))
-> CodeGenFunction r va
-> CodeGenFunction r vb
-> CodeGenFunction r vc
-> CodeGenFunction r (va, vb, vc)
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 (,,)
         (Iterator WriteMode (WriteIt va) va -> CodeGenFunction r va
forall v r.
Write v =>
WriteIterator (WriteIt v) v -> CodeGenFunction r v
forall r.
Iterator WriteMode (WriteIt va) va -> CodeGenFunction r va
writeStop (((WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt va)
-> ((va, vb, vc) -> va)
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
-> Iterator WriteMode (WriteIt va) va
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt va
forall a b c. (a, b, c) -> a
fst3 (va, vb, vc) -> va
forall a b c. (a, b, c) -> a
fst3 Iterator
  WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it))
         (Iterator WriteMode (WriteIt vb) vb -> CodeGenFunction r vb
forall v r.
Write v =>
WriteIterator (WriteIt v) v -> CodeGenFunction r v
forall r.
Iterator WriteMode (WriteIt vb) vb -> CodeGenFunction r vb
writeStop (((WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vb)
-> ((va, vb, vc) -> vb)
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
-> Iterator WriteMode (WriteIt vb) vb
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vb
forall a b c. (a, b, c) -> b
snd3 (va, vb, vc) -> vb
forall a b c. (a, b, c) -> b
snd3 Iterator
  WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it))
         (Iterator WriteMode (WriteIt vc) vc -> CodeGenFunction r vc
forall v r.
Write v =>
WriteIterator (WriteIt v) v -> CodeGenFunction r v
forall r.
Iterator WriteMode (WriteIt vc) vc -> CodeGenFunction r vc
writeStop (((WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vc)
-> ((va, vb, vc) -> vc)
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
-> Iterator WriteMode (WriteIt vc) vc
forall ita itb va vb mode.
(ita -> itb)
-> (va -> vb) -> Iterator mode ita va -> Iterator mode itb vb
fmapIt (WriteIt va, WriteIt vb, WriteIt vc) -> WriteIt vc
forall a b c. (a, b, c) -> c
thd3 (va, vb, vc) -> vc
forall a b c. (a, b, c) -> c
thd3 Iterator
  WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc)
it))

instance
   (Zero va, Zero vb, Zero vc, Size va ~ Size vb, Size vb ~ Size vc) =>
      Zero (va, vb, vc) where

   writeZero :: forall r.
CodeGenFunction
  r (WriteIterator (WriteIt (va, vb, vc)) (va, vb, vc))
writeZero = (Iterator WriteMode (WriteIt va) va
 -> Iterator WriteMode (WriteIt vb) vb
 -> Iterator WriteMode (WriteIt vc) vc
 -> Iterator
      WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc))
-> CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
-> CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
-> CodeGenFunction
     r
     (Iterator
        WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc))
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 Iterator WriteMode (WriteIt va) va
-> Iterator WriteMode (WriteIt vb) vb
-> Iterator WriteMode (WriteIt vc) vc
-> Iterator
     WriteMode (WriteIt va, WriteIt vb, WriteIt vc) (va, vb, vc)
forall mode xa va xb vb xc vc.
Iterator mode xa va
-> Iterator mode xb vb
-> Iterator mode xc vc
-> Iterator mode (xa, xb, xc) (va, vb, vc)
combineIt3 CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt va) va)
forall v r.
Zero v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeZero CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt vb) vb)
forall v r.
Zero v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeZero CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt vc) vc)
forall v r.
Zero v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeZero


instance (Sized value) => Sized (Stereo.T value) where
   type Size (Stereo.T value) = Size value

instance (Read v) => Read (Stereo.T v) where

   type Element (Stereo.T v) = Stereo.T (Element v)
   type ReadIt (Stereo.T v) = Stereo.T (ReadIt v)

   extract :: forall r. Value Word32 -> T v -> CodeGenFunction r (Element (T v))
extract = Value Word32 -> T v -> CodeGenFunction r (T (Element v))
Value Word32 -> T v -> CodeGenFunction r (Element (T v))
forall v (f :: * -> *) r.
(Read v, Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
extractTraversable

   readStart :: forall r.
T v -> CodeGenFunction r (ReadIterator (ReadIt (T v)) (T v))
readStart = T v -> CodeGenFunction r (ReadIterator (T (ReadIt v)) (T v))
T v -> CodeGenFunction r (ReadIterator (ReadIt (T v)) (T v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Read v) =>
f v -> CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v))
readStartTraversable
   readNext :: forall r.
ReadIterator (ReadIt (T v)) (T v)
-> CodeGenFunction
     r (Element (T v), ReadIterator (ReadIt (T v)) (T v))
readNext = ReadIterator (T (ReadIt v)) (T v)
-> CodeGenFunction
     r (T (Element v), ReadIterator (T (ReadIt v)) (T v))
ReadIterator (ReadIt (T v)) (T v)
-> CodeGenFunction
     r (Element (T v), ReadIterator (ReadIt (T v)) (T v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Read v) =>
ReadIterator (f (ReadIt v)) (f v)
-> CodeGenFunction
     r (f (Element v), ReadIterator (f (ReadIt v)) (f v))
readNextTraversable

instance (Write v) => Write (Stereo.T v) where

   type WriteIt (Stereo.T v) = Stereo.T (WriteIt v)

   insert :: forall r.
Value Word32 -> Element (T v) -> T v -> CodeGenFunction r (T v)
insert = Value Word32 -> T (Element v) -> T v -> CodeGenFunction r (T v)
Value Word32 -> Element (T v) -> T v -> CodeGenFunction r (T v)
forall v (f :: * -> *) r.
(Write v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
insertTraversable

   writeStart :: forall r. CodeGenFunction r (WriteIterator (WriteIt (T v)) (T v))
writeStart = CodeGenFunction r (WriteIterator (T (WriteIt v)) (T v))
CodeGenFunction r (WriteIterator (WriteIt (T v)) (T v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeStartTraversable
   writeNext :: forall r.
Element (T v)
-> WriteIterator (WriteIt (T v)) (T v)
-> CodeGenFunction r (WriteIterator (WriteIt (T v)) (T v))
writeNext = T (Element v)
-> WriteIterator (T (WriteIt v)) (T v)
-> CodeGenFunction r (WriteIterator (T (WriteIt v)) (T v))
Element (T v)
-> WriteIterator (WriteIt (T v)) (T v)
-> CodeGenFunction r (WriteIterator (WriteIt (T v)) (T v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
f (Element v)
-> WriteIterator (f (WriteIt v)) (f v)
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeNextTraversable
   writeStop :: forall r.
WriteIterator (WriteIt (T v)) (T v) -> CodeGenFunction r (T v)
writeStop = WriteIterator (T (WriteIt v)) (T v) -> CodeGenFunction r (T v)
WriteIterator (WriteIt (T v)) (T v) -> CodeGenFunction r (T v)
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
WriteIterator (f (WriteIt v)) (f v) -> CodeGenFunction r (f v)
writeStopTraversable

instance (Zero v) => Zero (Stereo.T v) where

   writeZero :: forall r. CodeGenFunction r (WriteIterator (WriteIt (T v)) (T v))
writeZero = CodeGenFunction r (WriteIterator (T (WriteIt v)) (T v))
CodeGenFunction r (WriteIterator (WriteIt (T v)) (T v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Zero v) =>
CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeZeroTraversable


insertTraversable ::
   (Write v, Trav.Traversable f, App.Applicative f) =>
   LLVM.Value Word32 -> f (Element v) -> f v -> LLVM.CodeGenFunction r (f v)
insertTraversable :: forall v (f :: * -> *) r.
(Write v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
insertTraversable Value Word32
n f (Element v)
a f v
v =
   f (CodeGenFunction r v) -> CodeGenFunction r (f v)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence ((Element v -> v -> CodeGenFunction r v)
-> f (Element v) -> f v -> f (CodeGenFunction r v)
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
n) f (Element v)
a f v
v)

extractTraversable ::
   (Read v, Trav.Traversable f) =>
   LLVM.Value Word32 -> f v -> LLVM.CodeGenFunction r (f (Element v))
extractTraversable :: forall v (f :: * -> *) r.
(Read v, Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
extractTraversable Value Word32
n f v
v =
   (v -> CodeGenFunction r (Element v))
-> f v -> CodeGenFunction r (f (Element v))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
Trav.mapM (Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
n) f v
v


readStartTraversable ::
   (Trav.Traversable f, App.Applicative f, Read v) =>
   f v -> LLVM.CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v))
readNextTraversable ::
   (Trav.Traversable f, App.Applicative f, Read v) =>
   ReadIterator (f (ReadIt v)) (f v) ->
   LLVM.CodeGenFunction r (f (Element v), ReadIterator (f (ReadIt v)) (f v))

readStartTraversable :: forall (f :: * -> *) v r.
(Traversable f, Applicative f, Read v) =>
f v -> CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v))
readStartTraversable f v
v =
   (f (Iterator ReadMode (ReadIt v) v)
 -> ReadIterator (f (ReadIt v)) (f v))
-> CodeGenFunction r (f (Iterator ReadMode (ReadIt v) v))
-> CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Iterator ReadMode (ReadIt v) v)
-> ReadIterator (f (ReadIt v)) (f v)
forall (f :: * -> *) mode x v.
Functor f =>
f (Iterator mode x v) -> Iterator mode (f x) (f v)
combineItFunctor (CodeGenFunction r (f (Iterator ReadMode (ReadIt v) v))
 -> CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v)))
-> CodeGenFunction r (f (Iterator ReadMode (ReadIt v) v))
-> CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v))
forall a b. (a -> b) -> a -> b
$ (v -> CodeGenFunction r (Iterator ReadMode (ReadIt v) v))
-> f v -> CodeGenFunction r (f (Iterator ReadMode (ReadIt v) v))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
Trav.mapM v -> CodeGenFunction r (Iterator ReadMode (ReadIt v) v)
forall r. v -> CodeGenFunction r (Iterator ReadMode (ReadIt v) v)
forall v r.
Read v =>
v -> CodeGenFunction r (ReadIterator (ReadIt v) v)
readStart f v
v

readNextTraversable :: forall (f :: * -> *) v r.
(Traversable f, Applicative f, Read v) =>
ReadIterator (f (ReadIt v)) (f v)
-> CodeGenFunction
     r (f (Element v), ReadIterator (f (ReadIt v)) (f v))
readNextTraversable ReadIterator (f (ReadIt v)) (f v)
it = do
   f (Element v, Iterator ReadMode (ReadIt v) v)
st <- (Iterator ReadMode (ReadIt v) v
 -> CodeGenFunction r (Element v, Iterator ReadMode (ReadIt v) v))
-> f (Iterator ReadMode (ReadIt v) v)
-> CodeGenFunction
     r (f (Element v, Iterator ReadMode (ReadIt v) v))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
Trav.mapM Iterator ReadMode (ReadIt v) v
-> CodeGenFunction r (Element v, Iterator ReadMode (ReadIt v) v)
forall v r.
Read v =>
ReadIterator (ReadIt v) v
-> CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)
forall r.
Iterator ReadMode (ReadIt v) v
-> CodeGenFunction r (Element v, Iterator ReadMode (ReadIt v) v)
readNext (f (Iterator ReadMode (ReadIt v) v)
 -> CodeGenFunction
      r (f (Element v, Iterator ReadMode (ReadIt v) v)))
-> f (Iterator ReadMode (ReadIt v) v)
-> CodeGenFunction
     r (f (Element v, Iterator ReadMode (ReadIt v) v))
forall a b. (a -> b) -> a -> b
$ ReadIterator (f (ReadIt v)) (f v)
-> f (Iterator ReadMode (ReadIt v) v)
forall (f :: * -> *) mode it v.
Functor f =>
Iterator mode (f it) (f v) -> f (Iterator mode it v)
sequenceItFunctor ReadIterator (f (ReadIt v)) (f v)
it
   (f (Element v), ReadIterator (f (ReadIt v)) (f v))
-> CodeGenFunction
     r (f (Element v), ReadIterator (f (ReadIt v)) (f v))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (((Element v, Iterator ReadMode (ReadIt v) v) -> Element v)
-> f (Element v, Iterator ReadMode (ReadIt v) v) -> f (Element v)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Element v, Iterator ReadMode (ReadIt v) v) -> Element v
forall a b. (a, b) -> a
fst f (Element v, Iterator ReadMode (ReadIt v) v)
st, f (Iterator ReadMode (ReadIt v) v)
-> ReadIterator (f (ReadIt v)) (f v)
forall (f :: * -> *) mode x v.
Functor f =>
f (Iterator mode x v) -> Iterator mode (f x) (f v)
combineItFunctor (f (Iterator ReadMode (ReadIt v) v)
 -> ReadIterator (f (ReadIt v)) (f v))
-> f (Iterator ReadMode (ReadIt v) v)
-> ReadIterator (f (ReadIt v)) (f v)
forall a b. (a -> b) -> a -> b
$ ((Element v, Iterator ReadMode (ReadIt v) v)
 -> Iterator ReadMode (ReadIt v) v)
-> f (Element v, Iterator ReadMode (ReadIt v) v)
-> f (Iterator ReadMode (ReadIt v) v)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Element v, Iterator ReadMode (ReadIt v) v)
-> Iterator ReadMode (ReadIt v) v
forall a b. (a, b) -> b
snd f (Element v, Iterator ReadMode (ReadIt v) v)
st)


writeStartTraversable ::
   (Trav.Traversable f, App.Applicative f, Write v) =>
   LLVM.CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeNextTraversable ::
   (Trav.Traversable f, App.Applicative f, Write v) =>
   f (Element v) -> WriteIterator (f (WriteIt v)) (f v) ->
   LLVM.CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeStopTraversable ::
   (Trav.Traversable f, App.Applicative f, Write v) =>
   WriteIterator (f (WriteIt v)) (f v) -> LLVM.CodeGenFunction r (f v)
writeZeroTraversable ::
   (Trav.Traversable f, App.Applicative f, Zero v) =>
   LLVM.CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))

writeStartTraversable :: forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeStartTraversable =
   (f (Iterator WriteMode (WriteIt v) v)
 -> WriteIterator (f (WriteIt v)) (f v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Iterator WriteMode (WriteIt v) v)
-> WriteIterator (f (WriteIt v)) (f v)
forall (f :: * -> *) mode x v.
Functor f =>
f (Iterator mode x v) -> Iterator mode (f x) (f v)
combineItFunctor (CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
 -> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v)))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
forall a b. (a -> b) -> a -> b
$ f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence (f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
 -> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v)))
-> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
forall a b. (a -> b) -> a -> b
$ CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
-> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
App.pure CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
forall v r.
Write v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeStart

writeNextTraversable :: forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
f (Element v)
-> WriteIterator (f (WriteIt v)) (f v)
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeNextTraversable f (Element v)
x WriteIterator (f (WriteIt v)) (f v)
it =
   (f (Iterator WriteMode (WriteIt v) v)
 -> WriteIterator (f (WriteIt v)) (f v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Iterator WriteMode (WriteIt v) v)
-> WriteIterator (f (WriteIt v)) (f v)
forall (f :: * -> *) mode x v.
Functor f =>
f (Iterator mode x v) -> Iterator mode (f x) (f v)
combineItFunctor (CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
 -> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v)))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
forall a b. (a -> b) -> a -> b
$ f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence (f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
 -> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v)))
-> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
forall a b. (a -> b) -> a -> b
$
   (Element v
 -> Iterator WriteMode (WriteIt v) v
 -> CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
-> f (Element v)
-> f (Iterator WriteMode (WriteIt v) v)
-> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Element v
-> Iterator WriteMode (WriteIt v) v
-> CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
forall v r.
Write v =>
Element v
-> WriteIterator (WriteIt v) v
-> CodeGenFunction r (WriteIterator (WriteIt v) v)
forall r.
Element v
-> Iterator WriteMode (WriteIt v) v
-> CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
writeNext f (Element v)
x (f (Iterator WriteMode (WriteIt v) v)
 -> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v)))
-> f (Iterator WriteMode (WriteIt v) v)
-> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
forall a b. (a -> b) -> a -> b
$ WriteIterator (f (WriteIt v)) (f v)
-> f (Iterator WriteMode (WriteIt v) v)
forall (f :: * -> *) mode it v.
Functor f =>
Iterator mode (f it) (f v) -> f (Iterator mode it v)
sequenceItFunctor WriteIterator (f (WriteIt v)) (f v)
it

writeStopTraversable :: forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
WriteIterator (f (WriteIt v)) (f v) -> CodeGenFunction r (f v)
writeStopTraversable = (Iterator WriteMode (WriteIt v) v -> CodeGenFunction r v)
-> f (Iterator WriteMode (WriteIt v) v) -> CodeGenFunction r (f v)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
Trav.mapM Iterator WriteMode (WriteIt v) v -> CodeGenFunction r v
forall v r.
Write v =>
WriteIterator (WriteIt v) v -> CodeGenFunction r v
forall r. Iterator WriteMode (WriteIt v) v -> CodeGenFunction r v
writeStop (f (Iterator WriteMode (WriteIt v) v) -> CodeGenFunction r (f v))
-> (Iterator WriteMode (f (WriteIt v)) (f v)
    -> f (Iterator WriteMode (WriteIt v) v))
-> Iterator WriteMode (f (WriteIt v)) (f v)
-> CodeGenFunction r (f v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Iterator WriteMode (f (WriteIt v)) (f v)
-> f (Iterator WriteMode (WriteIt v) v)
forall (f :: * -> *) mode it v.
Functor f =>
Iterator mode (f it) (f v) -> f (Iterator mode it v)
sequenceItFunctor

writeZeroTraversable :: forall (f :: * -> *) v r.
(Traversable f, Applicative f, Zero v) =>
CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
writeZeroTraversable =
   (f (Iterator WriteMode (WriteIt v) v)
 -> WriteIterator (f (WriteIt v)) (f v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Iterator WriteMode (WriteIt v) v)
-> WriteIterator (f (WriteIt v)) (f v)
forall (f :: * -> *) mode x v.
Functor f =>
f (Iterator mode x v) -> Iterator mode (f x) (f v)
combineItFunctor (CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
 -> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v)))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
forall a b. (a -> b) -> a -> b
$ f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence (f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
 -> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v)))
-> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
-> CodeGenFunction r (f (Iterator WriteMode (WriteIt v) v))
forall a b. (a -> b) -> a -> b
$ CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
-> f (CodeGenFunction r (Iterator WriteMode (WriteIt v) v))
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
App.pure CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
forall r. CodeGenFunction r (Iterator WriteMode (WriteIt v) v)
forall v r.
Zero v =>
CodeGenFunction r (WriteIterator (WriteIt v) v)
writeZero


modify ::
   (Write v, Element v ~ a) =>
   LLVM.Value Word32 ->
   (a -> LLVM.CodeGenFunction r a) ->
   v -> LLVM.CodeGenFunction r v
modify :: forall v a r.
(Write v, Element v ~ a) =>
Value Word32
-> (a -> CodeGenFunction r a) -> v -> CodeGenFunction r v
modify Value Word32
k a -> CodeGenFunction r a
f v
v = (a -> v -> CodeGenFunction r v) -> v -> a -> CodeGenFunction r v
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
Write v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k) v
v (a -> CodeGenFunction r v)
-> CodeGenFunction r a -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> CodeGenFunction r a
f (a -> CodeGenFunction r a)
-> CodeGenFunction r a -> CodeGenFunction r a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k v
v


last :: (Read v) => v -> LLVM.CodeGenFunction r (Element v)
last :: forall v r. Read v => v -> CodeGenFunction r (Element v)
last v
v = Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf (v -> Word32
forall v i. (Sized v, Integral i) => v -> i
size v
v Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1 :: Word32)) v
v

subsample :: (Read v) => v -> LLVM.CodeGenFunction r (Element v)
subsample :: forall v r. Read v => v -> CodeGenFunction r (Element v)
subsample v
v = Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Read v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Value Word32
forall a. Additive a => a
A.zero :: LLVM.Value Word32) v
v

-- this will be translated to an efficient pshufd
upsample :: (Write v) => Element v -> LLVM.CodeGenFunction r v
upsample :: forall v r. Write v => Element v -> CodeGenFunction r v
upsample Element v
x = (Int -> CodeGenFunction r v) -> CodeGenFunction r v
forall v (m :: * -> *). Sized v => (Int -> m v) -> m v
withSize ((Int -> CodeGenFunction r v) -> CodeGenFunction r v)
-> (Int -> CodeGenFunction r v) -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$ \Int
n -> [Element v] -> CodeGenFunction r v
forall r. [Element v] -> CodeGenFunction r v
forall v r. Write v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> [Element v] -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$ Int -> Element v -> [Element v]
forall a. Int -> a -> [a]
List.replicate Int
n Element v
x


iterate ::
   (Write v) =>
   (Element v -> LLVM.CodeGenFunction r (Element v)) ->
   Element v -> LLVM.CodeGenFunction r v
iterate :: forall v r.
Write v =>
(Element v -> CodeGenFunction r (Element v))
-> Element v -> CodeGenFunction r v
iterate Element v -> CodeGenFunction r (Element v)
f Element v
x =
   (Int -> CodeGenFunction r v) -> CodeGenFunction r v
forall v (m :: * -> *). Sized v => (Int -> m v) -> m v
withSize ((Int -> CodeGenFunction r v) -> CodeGenFunction r v)
-> (Int -> CodeGenFunction r v) -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$ \Int
n ->
      [Element v] -> CodeGenFunction r v
forall r. [Element v] -> CodeGenFunction r v
forall v r. Write v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> CodeGenFunction r [Element v] -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
      ((StateT (Element v) (CodeGenFunction r) [Element v]
 -> Element v -> CodeGenFunction r [Element v])
-> Element v
-> StateT (Element v) (CodeGenFunction r) [Element v]
-> CodeGenFunction r [Element v]
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT (Element v) (CodeGenFunction r) [Element v]
-> Element v -> CodeGenFunction r [Element v]
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT Element v
x (StateT (Element v) (CodeGenFunction r) [Element v]
 -> CodeGenFunction r [Element v])
-> StateT (Element v) (CodeGenFunction r) [Element v]
-> CodeGenFunction r [Element v]
forall a b. (a -> b) -> a -> b
$
       Int
-> StateT (Element v) (CodeGenFunction r) (Element v)
-> StateT (Element v) (CodeGenFunction r) [Element v]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
n (StateT (Element v) (CodeGenFunction r) (Element v)
 -> StateT (Element v) (CodeGenFunction r) [Element v])
-> StateT (Element v) (CodeGenFunction r) (Element v)
-> StateT (Element v) (CodeGenFunction r) [Element v]
forall a b. (a -> b) -> a -> b
$
       (Element v -> CodeGenFunction r (Element v, Element v))
-> StateT (Element v) (CodeGenFunction r) (Element v)
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
MS.StateT ((Element v -> CodeGenFunction r (Element v, Element v))
 -> StateT (Element v) (CodeGenFunction r) (Element v))
-> (Element v -> CodeGenFunction r (Element v, Element v))
-> StateT (Element v) (CodeGenFunction r) (Element v)
forall a b. (a -> b) -> a -> b
$ \Element v
x0 -> do Element v
x1 <- Element v -> CodeGenFunction r (Element v)
f Element v
x0; (Element v, Element v) -> CodeGenFunction r (Element v, Element v)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Element v
x0,Element v
x1))

reverse ::
   (Write v) =>
   v -> LLVM.CodeGenFunction r v
reverse :: forall v r. Write v => v -> CodeGenFunction r v
reverse =
   [Element v] -> CodeGenFunction r v
forall r. [Element v] -> CodeGenFunction r v
forall v r. Write v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> ([Element v] -> [Element v])
-> [Element v]
-> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Element v] -> [Element v]
forall a. [a] -> [a]
List.reverse ([Element v] -> CodeGenFunction r v)
-> (v -> CodeGenFunction r [Element v]) -> v -> CodeGenFunction r v
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< v -> CodeGenFunction r [Element v]
forall r. v -> CodeGenFunction r [Element v]
forall v r. Read v => v -> CodeGenFunction r [Element v]
dissect

shiftUp ::
   (Write v) =>
   Element v -> v -> LLVM.CodeGenFunction r (Element v, v)
shiftUp :: forall v r.
Write v =>
Element v -> v -> CodeGenFunction r (Element v, v)
shiftUp Element v
x v
v =
   CodeGenFunction r (Element v, v)
-> ([Element v] -> Element v -> CodeGenFunction r (Element v, v))
-> [Element v]
-> CodeGenFunction r (Element v, v)
forall b a. b -> ([a] -> a -> b) -> [a] -> b
ListHT.switchR
      ((Element v, v) -> CodeGenFunction r (Element v, v)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Element v
x,v
v))
      (\[Element v]
ys0 Element v
y -> (v -> (Element v, v))
-> CodeGenFunction r v -> CodeGenFunction r (Element v, v)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) Element v
y) (CodeGenFunction r v -> CodeGenFunction r (Element v, v))
-> CodeGenFunction r v -> CodeGenFunction r (Element v, v)
forall a b. (a -> b) -> a -> b
$ [Element v] -> CodeGenFunction r v
forall r. [Element v] -> CodeGenFunction r v
forall v r. Write v => [Element v] -> CodeGenFunction r v
assemble (Element v
xElement v -> [Element v] -> [Element v]
forall a. a -> [a] -> [a]
:[Element v]
ys0))
   ([Element v] -> CodeGenFunction r (Element v, v))
-> CodeGenFunction r [Element v]
-> CodeGenFunction r (Element v, v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
   v -> CodeGenFunction r [Element v]
forall r. v -> CodeGenFunction r [Element v]
forall v r. Read v => v -> CodeGenFunction r [Element v]
dissect v
v


shiftUpMultiZero ::
   (Write v, A.Additive (Element v)) =>
   Int -> v -> LLVM.CodeGenFunction r v
shiftUpMultiZero :: forall v r.
(Write v, Additive (Element v)) =>
Int -> v -> CodeGenFunction r v
shiftUpMultiZero Int
n v
v =
   [Element v] -> CodeGenFunction r v
forall r. [Element v] -> CodeGenFunction r v
forall v r. Write v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> ([Element v] -> [Element v])
-> [Element v]
-> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Element v] -> [Element v]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v i. (Sized v, Integral i) => v -> i
size v
v) ([Element v] -> [Element v])
-> ([Element v] -> [Element v]) -> [Element v] -> [Element v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Element v -> [Element v]
forall a. Int -> a -> [a]
List.replicate Int
n Element v
forall a. Additive a => a
A.zero [Element v] -> [Element v] -> [Element v]
forall a. [a] -> [a] -> [a]
++) ([Element v] -> CodeGenFunction r v)
-> CodeGenFunction r [Element v] -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< v -> CodeGenFunction r [Element v]
forall r. v -> CodeGenFunction r [Element v]
forall v r. Read v => v -> CodeGenFunction r [Element v]
dissect v
v

shiftDownMultiZero ::
   (Write v, A.Additive (Element v)) =>
   Int -> v -> LLVM.CodeGenFunction r v
shiftDownMultiZero :: forall v r.
(Write v, Additive (Element v)) =>
Int -> v -> CodeGenFunction r v
shiftDownMultiZero Int
n v
v =
   [Element v] -> CodeGenFunction r v
forall r. [Element v] -> CodeGenFunction r v
forall v r. Write v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> ([Element v] -> [Element v])
-> [Element v]
-> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Element v] -> [Element v]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v i. (Sized v, Integral i) => v -> i
size v
v) ([Element v] -> [Element v])
-> ([Element v] -> [Element v]) -> [Element v] -> [Element v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Element v] -> [Element v] -> [Element v]
forall a. [a] -> [a] -> [a]
++ Element v -> [Element v]
forall a. a -> [a]
List.repeat Element v
forall a. Additive a => a
A.zero) ([Element v] -> [Element v])
-> ([Element v] -> [Element v]) -> [Element v] -> [Element v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Element v] -> [Element v]
forall a. Int -> [a] -> [a]
List.drop Int
n
      ([Element v] -> CodeGenFunction r v)
-> CodeGenFunction r [Element v] -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< v -> CodeGenFunction r [Element v]
forall r. v -> CodeGenFunction r [Element v]
forall v r. Read v => v -> CodeGenFunction r [Element v]
dissect v
v