{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{- |
Re-export functions from "Sound.Frame.Stereo"
and add (orphan) instances for various LLVM type classes.
If you want to use the Stereo datatype with synthesizer-llvm
we recommend to import this module instead of
"Sound.Frame.Stereo" or "Sound.Frame.NumericPrelude.Stereo".
-}
module Synthesizer.LLVM.Frame.Stereo (
   Stereo.T, Stereo.cons, Stereo.left, Stereo.right,
   Stereo.Channel(Stereo.Left, Stereo.Right), Stereo.select,
   Stereo.swap,
   multiValue, unMultiValue, consMultiValue, unExpression,
   multiVector, unMultiVector,
   multiValueSerial, unMultiValueSerial,
   Stereo.arrowFromMono,
   Stereo.arrowFromMonoControlled,
   Stereo.arrowFromChannels,
   Stereo.interleave,
   Stereo.sequence,
   Stereo.liftApplicative,
   ) where

import qualified Synthesizer.LLVM.Frame.SerialVector as Serial
import qualified Synthesizer.Frame.Stereo as Stereo

import qualified LLVM.DSL.Expression as Expr
import qualified LLVM.DSL.Value as Value

import qualified LLVM.Extra.Multi.Vector as MultiVector
import qualified LLVM.Extra.Multi.Value.Storable as StorableMV
import qualified LLVM.Extra.Multi.Value.Marshal as MarshalMV
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.Tuple as Tuple
import qualified LLVM.Extra.Storable as Storable
import qualified LLVM.Extra.Marshal as Marshal
import qualified LLVM.Extra.Memory as Memory
import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Extra.Control as C
import qualified LLVM.Extra.Vector as Vector
import qualified LLVM.Core as LLVM

import Type.Data.Num.Decimal (d0, d1)

import Control.Applicative (liftA2, pure, (<$>))

import qualified Data.Traversable as Trav
import qualified Data.Foldable as Fold

import Prelude hiding (Either(Left, Right), sequence)


instance (Tuple.Zero a) => Tuple.Zero (Stereo.T a) where
   zero :: T a
zero = a -> a -> T a
forall a. a -> a -> T a
Stereo.cons a
forall a. Zero a => a
Tuple.zero a
forall a. Zero a => a
Tuple.zero

instance (Tuple.Undefined a) => Tuple.Undefined (Stereo.T a) where
   undef :: T a
undef = a -> a -> T a
forall a. a -> a -> T a
Stereo.cons a
forall a. Undefined a => a
Tuple.undef a
forall a. Undefined a => a
Tuple.undef

instance (C.Select a) => C.Select (Stereo.T a) where
   select :: forall r. Value Bool -> T a -> T a -> CodeGenFunction r (T a)
select = Value Bool -> T a -> T a -> CodeGenFunction r (T a)
forall a (f :: * -> *) r.
(Select a, Traversable f, Applicative f) =>
Value Bool -> f a -> f a -> CodeGenFunction r (f a)
C.selectTraversable

instance (Tuple.Value h) => Tuple.Value (Stereo.T h) where
   type ValueOf (Stereo.T h) = Stereo.T (Tuple.ValueOf h)
   valueOf :: T h -> ValueOf (T h)
valueOf = (h -> ValueOf h) -> T h -> T (ValueOf h)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap h -> ValueOf h
forall a. Value a => a -> ValueOf a
Tuple.valueOf

instance (Tuple.Phi a) => Tuple.Phi (Stereo.T a) where
   phi :: forall r. BasicBlock -> T a -> CodeGenFunction r (T a)
phi BasicBlock
bb T a
v =
      (a -> a -> T a)
-> CodeGenFunction r a
-> CodeGenFunction r a
-> CodeGenFunction r (T a)
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 a -> a -> T a
forall a. a -> a -> T a
Stereo.cons
         (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 (T a -> a
forall a. T a -> a
Stereo.left T a
v))
         (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 (T a -> a
forall a. T a -> a
Stereo.right T a
v))
   addPhi :: forall r. BasicBlock -> T a -> T a -> CodeGenFunction r ()
addPhi BasicBlock
bb T a
x T a
y = do
      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 (T a -> a
forall a. T a -> a
Stereo.left  T a
x) (T a -> a
forall a. T a -> a
Stereo.left  T a
y)
      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 (T a -> a
forall a. T a -> a
Stereo.right T a
x) (T a -> a
forall a. T a -> a
Stereo.right T a
y)

instance (MultiValue.C a) => MultiValue.C (Stereo.T a) where
   type Repr (Stereo.T a) = Stereo.T (MultiValue.Repr a)
   cons :: T a -> T (T a)
cons = T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (T (T a) -> T (T a)) -> (T a -> T (T a)) -> T a -> T (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> T a) -> T a -> T (T a)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> T a
forall a. C a => a -> T a
MultiValue.cons
   undef :: T (T a)
undef = T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (T (T a) -> T (T a)) -> T (T a) -> T (T a)
forall a b. (a -> b) -> a -> b
$ T a -> T (T a)
forall a. a -> T a
forall (f :: * -> *) a. Applicative f => a -> f a
pure T a
forall a. C a => T a
MultiValue.undef
   zero :: T (T a)
zero = T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (T (T a) -> T (T a)) -> T (T a) -> T (T a)
forall a b. (a -> b) -> a -> b
$ T a -> T (T a)
forall a. a -> T a
forall (f :: * -> *) a. Applicative f => a -> f a
pure T a
forall a. C a => T a
MultiValue.zero
   phi :: forall r. BasicBlock -> T (T a) -> CodeGenFunction r (T (T a))
phi BasicBlock
bb = (T (T a) -> T (T a))
-> CodeGenFunction r (T (T a)) -> CodeGenFunction r (T (T a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (CodeGenFunction r (T (T a)) -> CodeGenFunction r (T (T a)))
-> (T (T a) -> CodeGenFunction r (T (T a)))
-> T (T a)
-> CodeGenFunction r (T (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a -> CodeGenFunction r (T a))
-> T (T a) -> CodeGenFunction r (T (T a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse (BasicBlock -> T a -> CodeGenFunction r (T a)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T a -> CodeGenFunction r (T a)
MultiValue.phi BasicBlock
bb) (T (T a) -> CodeGenFunction r (T (T a)))
-> (T (T a) -> T (T a)) -> T (T a) -> CodeGenFunction r (T (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue
   addPhi :: forall r. BasicBlock -> T (T a) -> T (T a) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (T a)
a T (T a)
b =
      T (CodeGenFunction r ()) -> CodeGenFunction r ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
Fold.sequence_ (T (CodeGenFunction r ()) -> CodeGenFunction r ())
-> T (CodeGenFunction r ()) -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
      (T a -> T a -> CodeGenFunction r ())
-> T (T a) -> T (T a) -> T (CodeGenFunction r ())
forall a b c. (a -> b -> c) -> T a -> T b -> T c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T a -> T a -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb) (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
a) (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
b)

instance (MultiValue.Compose a) => MultiValue.Compose (Stereo.T a) where
   type Composed (Stereo.T a) = Stereo.T (MultiValue.Composed a)
   compose :: T a -> T (Composed (T a))
compose = T (T (Composed a)) -> T (T (Composed a))
forall a. T (T a) -> T (T a)
multiValue (T (T (Composed a)) -> T (T (Composed a)))
-> (T a -> T (T (Composed a))) -> T a -> T (T (Composed a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> T (Composed a)) -> T a -> T (T (Composed a))
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> T (Composed a)
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose

instance (MultiValue.Decompose p) => MultiValue.Decompose (Stereo.T p) where
   decompose :: T p -> T (PatternTuple (T p)) -> Decomposed T (T p)
decompose T p
p = (p -> T (PatternTuple p) -> Decomposed T p)
-> T p -> T (T (PatternTuple p)) -> T (Decomposed T p)
forall a b c. (a -> b -> c) -> T a -> T b -> T c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 p -> T (PatternTuple p) -> Decomposed T p
forall pattern.
Decompose pattern =>
pattern -> T (PatternTuple pattern) -> Decomposed T pattern
MultiValue.decompose T p
p (T (T (PatternTuple p)) -> T (Decomposed T p))
-> (T (T (PatternTuple p)) -> T (T (PatternTuple p)))
-> T (T (PatternTuple p))
-> T (Decomposed T p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (T (PatternTuple p)) -> T (T (PatternTuple p))
forall a. T (T a) -> T (T a)
unMultiValue

type instance MultiValue.Decomposed f (Stereo.T pa) =
                  Stereo.T (MultiValue.Decomposed f pa)
type instance MultiValue.PatternTuple (Stereo.T pa) =
                  Stereo.T (MultiValue.PatternTuple pa)

multiValue :: Stereo.T (MultiValue.T a) -> MultiValue.T (Stereo.T a)
multiValue :: forall a. T (T a) -> T (T a)
multiValue = Repr (T a) -> T (T a)
T (Repr a) -> T (T a)
forall a. Repr a -> T a
MultiValue.Cons (T (Repr a) -> T (T a))
-> (T (T a) -> T (Repr a)) -> T (T a) -> T (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a -> Repr a) -> T (T a) -> T (Repr a)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr a
a) -> Repr a
a)

unMultiValue :: MultiValue.T (Stereo.T a) -> Stereo.T (MultiValue.T a)
unMultiValue :: forall a. T (T a) -> T (T a)
unMultiValue (MultiValue.Cons Repr (T a)
x) = (Repr a -> T a) -> T (Repr a) -> T (T a)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Repr a -> T a
forall a. Repr a -> T a
MultiValue.Cons Repr (T a)
T (Repr a)
x

consMultiValue :: MultiValue.T a -> MultiValue.T a -> MultiValue.T (Stereo.T a)
consMultiValue :: forall a. T a -> T a -> T (T a)
consMultiValue T a
l T a
r = T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (T (T a) -> T (T a)) -> T (T a) -> T (T a)
forall a b. (a -> b) -> a -> b
$ T a -> T a -> T (T a)
forall a. a -> a -> T a
Stereo.cons T a
l T a
r


unExpression :: Expr.Exp (Stereo.T a) -> Stereo.T (Expr.Exp a)
unExpression :: forall a. Exp (T a) -> T (Exp a)
unExpression Exp (T a)
x =
   Exp a -> Exp a -> T (Exp a)
forall a. a -> a -> T a
Stereo.cons
      ((T (T a) -> T a) -> Exp (T a) -> Exp a
forall a b. (T a -> T b) -> Exp a -> Exp b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((Repr (T a) -> Repr a) -> T (T a) -> T a
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 Repr (T a) -> Repr a
T (Repr a) -> Repr a
forall a. T a -> a
Stereo.left) Exp (T a)
x)
      ((T (T a) -> T a) -> Exp (T a) -> Exp a
forall a b. (T a -> T b) -> Exp a -> Exp b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((Repr (T a) -> Repr a) -> T (T a) -> T a
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 Repr (T a) -> Repr a
T (Repr a) -> Repr a
forall a. T a -> a
Stereo.right) Exp (T a)
x)


instance (MultiVector.C a) => MultiVector.C (Stereo.T a) where
   type Repr n (Stereo.T a) = Stereo.T (MultiVector.Repr n a)
   cons :: forall n. Positive n => Vector n (T a) -> T n (T a)
cons = T (T n a) -> T n (T a)
forall n a. T (T n a) -> T n (T a)
multiVector (T (T n a) -> T n (T a))
-> (Vector n (T a) -> T (T n a)) -> Vector n (T a) -> T n (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Vector n a -> T n a) -> T (Vector n a) -> T (T n a)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector n a -> T n a
forall a n. (C a, Positive n) => Vector n a -> T n a
forall n. Positive n => Vector n a -> T n a
MultiVector.cons (T (Vector n a) -> T (T n a))
-> (Vector n (T a) -> T (Vector n a))
-> Vector n (T a)
-> T (T n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector n (T a) -> T (Vector n a)
forall (f :: * -> *) a. Functor f => f (T a) -> T (f a)
Stereo.sequence
   undef :: forall n. Positive n => T n (T a)
undef = T (T n a) -> T n (T a)
forall n a. T (T n a) -> T n (T a)
multiVector (T (T n a) -> T n (T a)) -> T (T n a) -> T n (T a)
forall a b. (a -> b) -> a -> b
$ T n a -> T (T n a)
forall a. a -> T a
forall (f :: * -> *) a. Applicative f => a -> f a
pure T n a
forall a n. (C a, Positive n) => T n a
forall n. Positive n => T n a
MultiVector.undef
   zero :: forall n. Positive n => T n (T a)
zero = T (T n a) -> T n (T a)
forall n a. T (T n a) -> T n (T a)
multiVector (T (T n a) -> T n (T a)) -> T (T n a) -> T n (T a)
forall a b. (a -> b) -> a -> b
$ T n a -> T (T n a)
forall a. a -> T a
forall (f :: * -> *) a. Applicative f => a -> f a
pure T n a
forall a n. (C a, Positive n) => T n a
forall n. Positive n => T n a
MultiVector.zero
   phi :: forall n r.
Positive n =>
BasicBlock -> T n (T a) -> CodeGenFunction r (T n (T a))
phi BasicBlock
bb =
      (T (T n a) -> T n (T a))
-> CodeGenFunction r (T (T n a)) -> CodeGenFunction r (T n (T a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T (T n a) -> T n (T a)
forall n a. T (T n a) -> T n (T a)
multiVector (CodeGenFunction r (T (T n a)) -> CodeGenFunction r (T n (T a)))
-> (T n (T a) -> CodeGenFunction r (T (T n a)))
-> T n (T a)
-> CodeGenFunction r (T n (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T n a -> CodeGenFunction r (T n a))
-> T (T n a) -> CodeGenFunction r (T (T n a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse (BasicBlock -> T n a -> CodeGenFunction r (T n a)
forall a n r.
(C a, Positive n) =>
BasicBlock -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
BasicBlock -> T n a -> CodeGenFunction r (T n a)
MultiVector.phi BasicBlock
bb) (T (T n a) -> CodeGenFunction r (T (T n a)))
-> (T n (T a) -> T (T n a))
-> T n (T a)
-> CodeGenFunction r (T (T n a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T n (T a) -> T (T n a)
forall n a. T n (T a) -> T (T n a)
unMultiVector
   addPhi :: forall n r.
Positive n =>
BasicBlock -> T n (T a) -> T n (T a) -> CodeGenFunction r ()
addPhi BasicBlock
bb T n (T a)
a T n (T a)
b =
      T (CodeGenFunction r ()) -> CodeGenFunction r ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
Fold.sequence_ (T (CodeGenFunction r ()) -> CodeGenFunction r ())
-> T (CodeGenFunction r ()) -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
      (T n a -> T n a -> CodeGenFunction r ())
-> T (T n a) -> T (T n a) -> T (CodeGenFunction r ())
forall a b c. (a -> b -> c) -> T a -> T b -> T c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (BasicBlock -> T n a -> T n a -> CodeGenFunction r ()
forall a n r.
(C a, Positive n) =>
BasicBlock -> T n a -> T n a -> CodeGenFunction r ()
forall n r.
Positive n =>
BasicBlock -> T n a -> T n a -> CodeGenFunction r ()
MultiVector.addPhi BasicBlock
bb) (T n (T a) -> T (T n a)
forall n a. T n (T a) -> T (T n a)
unMultiVector T n (T a)
a) (T n (T a) -> T (T n a)
forall n a. T n (T a) -> T (T n a)
unMultiVector T n (T a)
b)

   shuffle :: forall n m r.
(Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n (T a) -> T n (T a) -> CodeGenFunction r (T m (T a))
shuffle ConstValue (Vector m Word32)
is T n (T a)
u T n (T a)
v =
      T (T m a) -> T m (T a)
forall n a. T (T n a) -> T n (T a)
multiVector (T (T m a) -> T m (T a))
-> CodeGenFunction r (T (T m a)) -> CodeGenFunction r (T m (T a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
      (T n a -> T n a -> CodeGenFunction r (T m a))
-> T (T n a) -> T (T n a) -> CodeGenFunction r (T (T m a))
forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Applicative t, Traversable t) =>
(a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 (ConstValue (Vector m Word32)
-> T n a -> T n a -> CodeGenFunction r (T m a)
forall a n m r.
(C a, Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n a -> T n a -> CodeGenFunction r (T m a)
forall n m r.
(Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n a -> T n a -> CodeGenFunction r (T m a)
MultiVector.shuffle ConstValue (Vector m Word32)
is) (T n (T a) -> T (T n a)
forall n a. T n (T a) -> T (T n a)
unMultiVector T n (T a)
u) (T n (T a) -> T (T n a)
forall n a. T n (T a) -> T (T n a)
unMultiVector T n (T a)
v)
   extract :: forall n r.
Positive n =>
Value Word32 -> T n (T a) -> CodeGenFunction r (T (T a))
extract Value Word32
k =
      (T (T a) -> T (T a))
-> CodeGenFunction r (T (T a)) -> CodeGenFunction r (T (T a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (CodeGenFunction r (T (T a)) -> CodeGenFunction r (T (T a)))
-> (T n (T a) -> CodeGenFunction r (T (T a)))
-> T n (T a)
-> CodeGenFunction r (T (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T n a -> CodeGenFunction r (T a))
-> T (T n a) -> CodeGenFunction r (T (T a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse (Value Word32 -> T n a -> CodeGenFunction r (T 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 Value Word32
k) (T (T n a) -> CodeGenFunction r (T (T a)))
-> (T n (T a) -> T (T n a))
-> T n (T a)
-> CodeGenFunction r (T (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T n (T a) -> T (T n a)
forall n a. T n (T a) -> T (T n a)
unMultiVector
   insert :: forall n r.
Positive n =>
Value Word32
-> T (T a) -> T n (T a) -> CodeGenFunction r (T n (T a))
insert Value Word32
k T (T a)
a T n (T a)
v =
      T (T n a) -> T n (T a)
forall n a. T (T n a) -> T n (T a)
multiVector (T (T n a) -> T n (T a))
-> CodeGenFunction r (T (T n a)) -> CodeGenFunction r (T n (T a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
      (T a -> T n a -> CodeGenFunction r (T n a))
-> T (T a) -> T (T n a) -> CodeGenFunction r (T (T n a))
forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Applicative t, Traversable t) =>
(a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 (Value Word32 -> T 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 Value Word32
k) (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
a) (T n (T a) -> T (T n a)
forall n a. T n (T a) -> T (T n a)
unMultiVector T n (T a)
v)

multiVector :: Stereo.T (MultiVector.T n a) -> MultiVector.T n (Stereo.T a)
multiVector :: forall n a. T (T n a) -> T n (T a)
multiVector = Repr n (T a) -> T n (T a)
T (Repr n a) -> T n (T a)
forall n a. Repr n a -> T n a
MultiVector.Cons (T (Repr n a) -> T n (T a))
-> (T (T n a) -> T (Repr n a)) -> T (T n a) -> T n (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T n a -> Repr n a) -> T (T n a) -> T (Repr n a)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiVector.Cons Repr n a
a) -> Repr n a
a)

unMultiVector :: MultiVector.T n (Stereo.T a) -> Stereo.T (MultiVector.T n a)
unMultiVector :: forall n a. T n (T a) -> T (T n a)
unMultiVector (MultiVector.Cons Repr n (T a)
x) = (Repr n a -> T n a) -> T (Repr n a) -> T (T n a)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Repr n a -> T n a
forall n a. Repr n a -> T n a
MultiVector.Cons Repr n (T a)
T (Repr n a)
x


multiValueSerial ::
   Stereo.T (MultiValue.T (Serial.T n a)) ->
   MultiValue.T (Serial.T n (Stereo.T a))
multiValueSerial :: forall n a. T (T (T n a)) -> T (T n (T a))
multiValueSerial = Repr (T n (T a)) -> T (T n (T a))
T (Repr n a) -> T (T n (T a))
forall a. Repr a -> T a
MultiValue.Cons (T (Repr n a) -> T (T n (T a)))
-> (T (T (T n a)) -> T (Repr n a))
-> T (T (T n a))
-> T (T n (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T (T n a) -> Repr n a) -> T (T (T n a)) -> T (Repr n a)
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr (T n a)
a) -> Repr (T n a)
Repr n a
a)

unMultiValueSerial ::
   MultiValue.T (Serial.T n (Stereo.T a)) ->
   Stereo.T (MultiValue.T (Serial.T n a))
unMultiValueSerial :: forall n a. T (T n (T a)) -> T (T (T n a))
unMultiValueSerial (MultiValue.Cons Repr (T n (T a))
x) = (Repr n a -> T (T n a)) -> T (Repr n a) -> T (T (T n a))
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Repr (T n a) -> T (T n a)
Repr n a -> T (T n a)
forall a. Repr a -> T a
MultiValue.Cons Repr (T n (T a))
T (Repr n a)
x


instance
      (Expr.Aggregate e mv) => Expr.Aggregate (Stereo.T e) (Stereo.T mv) where
   type MultiValuesOf (Stereo.T e) = Stereo.T (Expr.MultiValuesOf e)
   type ExpressionsOf (Stereo.T mv) = Stereo.T (Expr.ExpressionsOf mv)
   bundle :: forall r. T e -> CodeGenFunction r (T mv)
bundle = (e -> CodeGenFunction r mv) -> T e -> CodeGenFunction r (T mv)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse e -> CodeGenFunction r mv
forall r. e -> CodeGenFunction r mv
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
Expr.bundle
   dissect :: T mv -> T e
dissect = (mv -> e) -> T mv -> T e
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap mv -> e
forall exp mv. Aggregate exp mv => mv -> exp
Expr.dissect


instance (Vector.Simple v) => Vector.Simple (Stereo.T v) where
   type Element (Stereo.T v) = Stereo.T (Vector.Element v)
   type Size (Stereo.T v) = Vector.Size v
   shuffleMatch :: forall r.
ConstValue (Vector (Size (T v)) Word32)
-> T v -> CodeGenFunction r (T v)
shuffleMatch = ConstValue (Vector (Size v) Word32)
-> T v -> CodeGenFunction r (T v)
ConstValue (Vector (Size (T v)) Word32)
-> T v -> CodeGenFunction r (T v)
forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
ConstValue (Vector (Size v) Word32)
-> f v -> CodeGenFunction r (f v)
Vector.shuffleMatchTraversable
   extract :: forall r. Value Word32 -> T v -> CodeGenFunction r (Element (T v))
extract = Value Word32 -> T v -> CodeGenFunction r (Element (T v))
Value Word32 -> T v -> CodeGenFunction r (T (Element v))
forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
Vector.extractTraversable

instance (Vector.C v) => Vector.C (Stereo.T v) where
   insert :: forall r.
Value Word32 -> Element (T v) -> T v -> CodeGenFunction r (T v)
insert = Value Word32 -> Element (T v) -> T v -> CodeGenFunction r (T v)
Value Word32 -> T (Element v) -> T v -> CodeGenFunction r (T v)
forall v (f :: * -> *) r.
(C v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
Vector.insertTraversable


type Struct a = LLVM.Struct (a, (a, ()))

memory ::
   (Memory.C l) =>
   Memory.Record r (Struct (Memory.Struct l)) (Stereo.T l)
memory :: forall l r. C l => Record r (Struct (Struct l)) (T l)
memory =
   (l -> l -> T l)
-> Element r (Struct (Struct l)) (T l) l
-> Element r (Struct (Struct l)) (T l) l
-> Element r (Struct (Struct l)) (T l) (T l)
forall a b c.
(a -> b -> c)
-> Element r (Struct (Struct l)) (T l) a
-> Element r (Struct (Struct l)) (T l) b
-> Element r (Struct (Struct l)) (T l) c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 l -> l -> T l
forall a. a -> a -> T a
Stereo.cons
      ((T l -> l) -> Proxy D0 -> Element r (Struct (Struct l)) (T l) l
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element T l -> l
forall a. T a -> a
Stereo.left  Proxy D0
d0)
      ((T l -> l) -> Proxy D1 -> Element r (Struct (Struct l)) (T l) l
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element T l -> l
forall a. T a -> a
Stereo.right Proxy D1
d1)

instance (Memory.C l) => Memory.C (Stereo.T l) where
   type Struct (Stereo.T l) = Struct (Memory.Struct l)
   load :: forall r. Value (Ptr (Struct (T l))) -> CodeGenFunction r (T l)
load = Record r (Struct (Struct l)) (T l)
-> Value (Ptr (Struct (Struct l))) -> CodeGenFunction r (T l)
forall r o llvmValue.
Record r o llvmValue
-> Value (Ptr o) -> CodeGenFunction r llvmValue
Memory.loadRecord Record r (Struct (Struct l)) (T l)
forall l r. C l => Record r (Struct (Struct l)) (T l)
memory
   store :: forall r. T l -> Value (Ptr (Struct (T l))) -> CodeGenFunction r ()
store = Record r (Struct (Struct l)) (T l)
-> T l -> Value (Ptr (Struct (Struct l))) -> CodeGenFunction r ()
forall r o llvmValue.
Record r o llvmValue
-> llvmValue -> Value (Ptr o) -> CodeGenFunction r ()
Memory.storeRecord Record r (Struct (Struct l)) (T l)
forall l r. C l => Record r (Struct (Struct l)) (T l)
memory
   decompose :: forall r. Value (Struct (T l)) -> CodeGenFunction r (T l)
decompose = Record r (Struct (Struct l)) (T l)
-> Value (Struct (Struct l)) -> CodeGenFunction r (T l)
forall r o llvmValue.
Record r o llvmValue -> Value o -> CodeGenFunction r llvmValue
Memory.decomposeRecord Record r (Struct (Struct l)) (T l)
forall l r. C l => Record r (Struct (Struct l)) (T l)
memory
   compose :: forall r. T l -> CodeGenFunction r (Value (Struct (T l)))
compose = Record r (Struct (Struct l)) (T l)
-> T l -> CodeGenFunction r (Value (Struct (Struct l)))
forall o r llvmValue.
IsType o =>
Record r o llvmValue -> llvmValue -> CodeGenFunction r (Value o)
Memory.composeRecord Record r (Struct (Struct l)) (T l)
forall l r. C l => Record r (Struct (Struct l)) (T l)
memory

instance (Marshal.C l) => Marshal.C (Stereo.T l) where
   pack :: T l -> Struct (T l)
pack T l
x = (l, l) -> Struct (l, l)
forall a. C a => a -> Struct a
Marshal.pack (T l -> l
forall a. T a -> a
Stereo.left T l
x, T l -> l
forall a. T a -> a
Stereo.right T l
x)
   unpack :: Struct (T l) -> T l
unpack = (l -> l -> T l) -> (l, l) -> T l
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry l -> l -> T l
forall a. a -> a -> T a
Stereo.cons ((l, l) -> T l)
-> (Struct (Struct l) -> (l, l)) -> Struct (Struct l) -> T l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct (l, l) -> (l, l)
Struct (Struct l) -> (l, l)
forall a. C a => Struct a -> a
Marshal.unpack

instance (Storable.C l) => Storable.C (Stereo.T l) where
   load :: forall r. Value (Ptr (T l)) -> CodeGenFunction r (ValueOf (T l))
load = Value (Ptr (T l)) -> CodeGenFunction r (ValueOf (T l))
Value (Ptr (T l)) -> CodeGenFunction r (T (ValueOf l))
forall (f :: * -> *) a al r.
(Applicative f, Traversable f, C a, ValueOf a ~ al) =>
Value (Ptr (f a)) -> CodeGenFunction r (f al)
Storable.loadApplicative
   store :: forall r.
ValueOf (T l) -> Value (Ptr (T l)) -> CodeGenFunction r ()
store = ValueOf (T l) -> Value (Ptr (T l)) -> CodeGenFunction r ()
T (ValueOf l) -> Value (Ptr (T l)) -> CodeGenFunction r ()
forall (f :: * -> *) a al r.
(Foldable f, C a, ValueOf a ~ al) =>
f al -> Value (Ptr (f a)) -> CodeGenFunction r ()
Storable.storeFoldable

instance (MarshalMV.C l) => MarshalMV.C (Stereo.T l) where
   pack :: T l -> Struct (T l)
pack T l
x = (l, l) -> Struct (l, l)
forall a. C a => a -> Struct a
MarshalMV.pack (T l -> l
forall a. T a -> a
Stereo.left T l
x, T l -> l
forall a. T a -> a
Stereo.right T l
x)
   unpack :: Struct (T l) -> T l
unpack = (l -> l -> T l) -> (l, l) -> T l
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry l -> l -> T l
forall a. a -> a -> T a
Stereo.cons ((l, l) -> T l)
-> (Struct (Struct (Repr l)) -> (l, l))
-> Struct (Struct (Repr l))
-> T l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct (l, l) -> (l, l)
Struct (Struct (Repr l)) -> (l, l)
forall a. C a => Struct a -> a
MarshalMV.unpack

instance (StorableMV.C l) => StorableMV.C (Stereo.T l) where
   load :: forall r. Value (Ptr (T l)) -> CodeGenFunction r (T (T l))
load = Value (Ptr (T l)) -> CodeGenFunction r (T (T l))
forall (f :: * -> *) a fa r.
(Applicative f, Traversable f, C a, Repr fa ~ f (Repr a)) =>
Value (Ptr (f a)) -> CodeGenFunction r (T fa)
StorableMV.loadApplicative
   store :: forall r. T (T l) -> Value (Ptr (T l)) -> CodeGenFunction r ()
store = T (T l) -> Value (Ptr (T l)) -> CodeGenFunction r ()
forall (f :: * -> *) a fa r.
(Foldable f, C a, Repr fa ~ f (Repr a)) =>
T fa -> Value (Ptr (f a)) -> CodeGenFunction r ()
StorableMV.storeFoldable

instance
   (StorableMV.Vector l, MultiVector.C l) =>
      StorableMV.Vector (Stereo.T l) where
   assembleVector :: forall n r.
Positive n =>
Proxy (T l)
-> Vector n (Repr (T l)) -> CodeGenFunction r (Repr n (T l))
assembleVector Proxy (T l)
p =
      (Vector n (Repr l) -> CodeGenFunction r (Repr n l))
-> T (Vector n (Repr l)) -> CodeGenFunction r (T (Repr n l))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse (Proxy l -> Vector n (Repr l) -> CodeGenFunction r (Repr n l)
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy l -> Vector n (Repr l) -> CodeGenFunction r (Repr n l)
StorableMV.assembleVector (T l -> l
forall a. T a -> a
Stereo.left(T l -> l) -> Proxy (T l) -> Proxy l
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>Proxy (T l)
p)) (T (Vector n (Repr l)) -> CodeGenFunction r (T (Repr n l)))
-> (Vector n (T (Repr l)) -> T (Vector n (Repr l)))
-> Vector n (T (Repr l))
-> CodeGenFunction r (T (Repr n l))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      Vector n (T (Repr l)) -> T (Vector n (Repr l))
forall (f :: * -> *) a. Functor f => f (T a) -> T (f a)
Stereo.sequence
   disassembleVector :: forall n r.
Positive n =>
Proxy (T l)
-> Repr n (T l) -> CodeGenFunction r (Vector n (Repr (T l)))
disassembleVector Proxy (T l)
p =
      (T (Vector n (Repr l)) -> Vector n (T (Repr l)))
-> CodeGenFunction r (T (Vector n (Repr l)))
-> CodeGenFunction r (Vector n (T (Repr l)))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\T (Vector n (Repr l))
x -> (Repr l -> Repr l -> T (Repr l))
-> Vector n (Repr l) -> Vector n (Repr l) -> Vector n (T (Repr l))
forall a b c.
(a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Repr l -> Repr l -> T (Repr l)
forall a. a -> a -> T a
Stereo.cons (T (Vector n (Repr l)) -> Vector n (Repr l)
forall a. T a -> a
Stereo.left T (Vector n (Repr l))
x) (T (Vector n (Repr l)) -> Vector n (Repr l)
forall a. T a -> a
Stereo.right T (Vector n (Repr l))
x)) (CodeGenFunction r (T (Vector n (Repr l)))
 -> CodeGenFunction r (Vector n (T (Repr l))))
-> (T (Repr n l) -> CodeGenFunction r (T (Vector n (Repr l))))
-> T (Repr n l)
-> CodeGenFunction r (Vector n (T (Repr l)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (Repr n l -> CodeGenFunction r (Vector n (Repr l)))
-> T (Repr n l) -> CodeGenFunction r (T (Vector n (Repr l)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse (Proxy l -> Repr n l -> CodeGenFunction r (Vector n (Repr l))
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy l -> Repr n l -> CodeGenFunction r (Vector n (Repr l))
StorableMV.disassembleVector (T l -> l
forall a. T a -> a
Stereo.left(T l -> l) -> Proxy (T l) -> Proxy l
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>Proxy (T l)
p))


{-
instance
      (Memory l s) =>
      Memory (Stereo.T l) (LLVM.Struct (s, (s, ()))) where
   load ptr =
      liftA2 Stereo.cons
         (load =<< getElementPtr0 ptr (d0, ()))
         (load =<< getElementPtr0 ptr (d1, ()))
   store y ptr = do
      store (Stereo.left  y) =<< getElementPtr0 ptr (d0, ())
      store (Stereo.right y) =<< getElementPtr0 ptr (d1, ())
-}

instance (A.Additive a) => A.Additive (Stereo.T a) where
   zero :: T a
zero = a -> a -> T a
forall a. a -> a -> T a
Stereo.cons a
forall a. Additive a => a
A.zero a
forall a. Additive a => a
A.zero
   add :: forall r. T a -> T a -> CodeGenFunction r (T a)
add T a
x T a
y = (a -> a -> CodeGenFunction r a)
-> T a -> T a -> CodeGenFunction r (T a)
forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Applicative t, Traversable t) =>
(a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. Additive a => a -> a -> CodeGenFunction r a
A.add T a
x T a
y
   sub :: forall r. T a -> T a -> CodeGenFunction r (T a)
sub T a
x T a
y = (a -> a -> CodeGenFunction r a)
-> T a -> T a -> CodeGenFunction r (T a)
forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Applicative t, Traversable t) =>
(a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. Additive a => a -> a -> CodeGenFunction r a
A.sub T a
x T a
y
   neg :: forall r. T a -> CodeGenFunction r (T a)
neg T a
x   = (a -> CodeGenFunction r a) -> T a -> CodeGenFunction r (T a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse a -> CodeGenFunction r a
forall r. a -> CodeGenFunction r a
forall a r. Additive a => a -> CodeGenFunction r a
A.neg T a
x

type instance A.Scalar (Stereo.T a) = A.Scalar a

instance (A.PseudoModule a) => A.PseudoModule (Stereo.T a) where
   scale :: forall r. Scalar (T a) -> T a -> CodeGenFunction r (T a)
scale Scalar (T a)
a = (a -> CodeGenFunction r a) -> T a -> CodeGenFunction r (T a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse (Scalar a -> a -> CodeGenFunction r a
forall v r. PseudoModule v => Scalar v -> v -> CodeGenFunction r v
forall r. Scalar a -> a -> CodeGenFunction r a
A.scale Scalar a
Scalar (T a)
a)



instance (MultiValue.Additive a) => MultiValue.Additive (Stereo.T a) where
   add :: forall r. T (T a) -> T (T a) -> CodeGenFunction r (T (T a))
add T (T a)
x T (T a)
y =
      T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (T (T a) -> T (T a))
-> CodeGenFunction r (T (T a)) -> CodeGenFunction r (T (T a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (T a -> T a -> CodeGenFunction r (T a))
-> T (T a) -> T (T a) -> CodeGenFunction r (T (T a))
forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Applicative t, Traversable t) =>
(a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Additive a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.add (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
x) (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
y)
   sub :: forall r. T (T a) -> T (T a) -> CodeGenFunction r (T (T a))
sub T (T a)
x T (T a)
y =
      T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (T (T a) -> T (T a))
-> CodeGenFunction r (T (T a)) -> CodeGenFunction r (T (T a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (T a -> T a -> CodeGenFunction r (T a))
-> T (T a) -> T (T a) -> CodeGenFunction r (T (T a))
forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Applicative t, Traversable t) =>
(a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Additive a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.sub (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
x) (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
y)
   neg :: forall r. T (T a) -> CodeGenFunction r (T (T a))
neg T (T a)
x = T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
multiValue (T (T a) -> T (T a))
-> CodeGenFunction r (T (T a)) -> CodeGenFunction r (T (T a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (T a -> CodeGenFunction r (T a))
-> T (T a) -> CodeGenFunction r (T (T a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T a -> f (T b)
Trav.traverse T a -> CodeGenFunction r (T a)
forall a r. Additive a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.neg (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
unMultiValue T (T a)
x)


traverse2 ::
   (Monad m, Applicative t, Traversable t) =>
   (a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 :: forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Applicative t, Traversable t) =>
(a -> b -> m c) -> t a -> t b -> m (t c)
traverse2 a -> b -> m c
f t a
x t b
y = t (m c) -> m (t c)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => t (m a) -> m (t a)
Trav.sequence (t (m c) -> m (t c)) -> t (m c) -> m (t c)
forall a b. (a -> b) -> a -> b
$ (a -> b -> m c) -> t a -> t b -> t (m c)
forall a b c. (a -> b -> c) -> t a -> t b -> t c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> b -> m c
f t a
x t b
y



instance Value.Flatten a => Value.Flatten (Stereo.T a) where
   type Registers (Stereo.T a) = Stereo.T (Value.Registers a)
   flattenCode :: forall r. T a -> Compute r (Registers (T a))
flattenCode = T a -> StateT Vault (CodeGenFunction r) (Registers (T a))
T a -> Compute r (T (Registers a))
forall value (f :: * -> *) r.
(Flatten value, Traversable f) =>
f value -> Compute r (f (Registers value))
Value.flattenCodeTraversable
   unfoldCode :: T (Registers (T a)) -> T a
unfoldCode = T (Registers (T a)) -> T a
T (T (Registers a)) -> T a
forall value (f :: * -> *).
(Flatten value, Traversable f, Applicative f) =>
T (f (Registers value)) -> f value
Value.unfoldCodeTraversable