{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
module LLVM.DSL.Expression where

import qualified LLVM.Extra.ScalarOrVector as SoV
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.FastMath as FastMath
import qualified LLVM.Extra.Scalar as Scalar
import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Extra.Control as C
import qualified LLVM.Core as LLVM
import LLVM.Extra.Multi.Value (PatternTuple, Decomposed, Atom)

import qualified Control.Monad.HT as Monad
import Control.Monad.IO.Class (liftIO)

import qualified Data.Enum.Storable as Enum
import qualified Data.Tuple.HT as TupleHT
import qualified Data.Tuple as Tuple
import Data.IORef (IORef, newIORef, readIORef, writeIORef)
import Data.Complex (Complex((:+)))
import Data.Bool8 (Bool8)

import qualified Foreign.Storable.Record.Tuple as StTuple

import qualified Algebra.Transcendental as Trans
import qualified Algebra.Algebraic as Algebraic
import qualified Algebra.Absolute as Absolute
import qualified Algebra.Module as Module
import qualified Algebra.Field as Field
import qualified Algebra.Ring as Ring
import qualified Algebra.Additive as Additive

import qualified Number.Complex as Complex

import System.IO.Unsafe (unsafePerformIO)

import qualified Prelude as P
import Prelude hiding
   (fst, snd, min, max, zip, unzip, zip3, unzip3,
    curry, uncurry, recip, pi, sqrt, maybe, toEnum, fromEnum, pred, succ)


newtype Exp a = Exp {forall a. Exp a -> forall r. CodeGenFunction r (T a)
unExp :: forall r. LLVM.CodeGenFunction r (MultiValue.T a)}


{-
Using IORef should be thread-safe here,
because you cannot fork within CodeGenFunction.
-}
unique :: (forall r. LLVM.CodeGenFunction r (MultiValue.T a)) -> Exp a
unique :: forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique = (forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
Exp

_unique :: (forall r. LLVM.CodeGenFunction r (MultiValue.T a)) -> Exp a
_unique :: forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
_unique forall r. CodeGenFunction r (T a)
code = IO (Exp a) -> Exp a
forall a. IO a -> a
unsafePerformIO (IO (Exp a) -> Exp a) -> IO (Exp a) -> Exp a
forall a b. (a -> b) -> a -> b
$ (IORef (Maybe (T a)) -> Exp a)
-> IO (IORef (Maybe (T a))) -> IO (Exp a)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((forall r. CodeGenFunction r (T a)) -> IORef (Maybe (T a)) -> Exp a
forall a.
(forall r. CodeGenFunction r (T a)) -> IORef (Maybe (T a)) -> Exp a
withKey CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
code) (IO (IORef (Maybe (T a))) -> IO (Exp a))
-> IO (IORef (Maybe (T a))) -> IO (Exp a)
forall a b. (a -> b) -> a -> b
$ Maybe (T a) -> IO (IORef (Maybe (T a)))
forall a. a -> IO (IORef a)
newIORef Maybe (T a)
forall a. Maybe a
Nothing

withKey ::
   (forall r. LLVM.CodeGenFunction r (MultiValue.T a)) ->
   IORef (Maybe (MultiValue.T a)) -> Exp a
withKey :: forall a.
(forall r. CodeGenFunction r (T a)) -> IORef (Maybe (T a)) -> Exp a
withKey forall r. CodeGenFunction r (T a)
code IORef (Maybe (T a))
ref =
   (forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
Exp (do
      Maybe (T a)
ma <- IO (Maybe (T a)) -> CodeGenFunction r (Maybe (T a))
forall a. IO a -> CodeGenFunction r a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (T a)) -> CodeGenFunction r (Maybe (T a)))
-> IO (Maybe (T a)) -> CodeGenFunction r (Maybe (T a))
forall a b. (a -> b) -> a -> b
$ IORef (Maybe (T a)) -> IO (Maybe (T a))
forall a. IORef a -> IO a
readIORef IORef (Maybe (T a))
ref
      case Maybe (T a)
ma of
         Just T a
a -> T a -> CodeGenFunction r (T a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return T a
a
         Maybe (T a)
Nothing -> do
            T a
a <- CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
code
            IO () -> CodeGenFunction r ()
forall a. IO a -> CodeGenFunction r a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> CodeGenFunction r ()) -> IO () -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$ IORef (Maybe (T a)) -> Maybe (T a) -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (Maybe (T a))
ref (Maybe (T a) -> IO ()) -> Maybe (T a) -> IO ()
forall a b. (a -> b) -> a -> b
$ T a -> Maybe (T a)
forall a. a -> Maybe a
Just T a
a
            T a -> CodeGenFunction r (T a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return T a
a)


with :: Exp a -> (Exp a -> Exp b) -> Exp b
with :: forall a b. Exp a -> (Exp a -> Exp b) -> Exp b
with (Exp forall r. CodeGenFunction r (T a)
code) Exp a -> Exp b
f =
   (forall r. CodeGenFunction r (T b)) -> Exp b
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
Exp (do
      T a
a <- CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
code
      Exp b -> forall r. CodeGenFunction r (T b)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
unExp (Exp a -> Exp b
f ((forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
Exp (T a -> CodeGenFunction r (T a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return T a
a))))


class Value val where
   lift0 :: MultiValue.T a -> val a
   lift1 ::
      (MultiValue.T a -> MultiValue.T b) ->
      val a -> val b
   lift2 ::
      (MultiValue.T a -> MultiValue.T b -> MultiValue.T c) ->
      val a -> val b -> val c

instance Value MultiValue.T where
   lift0 :: forall a. T a -> T a
lift0 = T a -> T a
forall a. a -> a
id
   lift1 :: forall a b. (T a -> T b) -> T a -> T b
lift1 = (T a -> T b) -> T a -> T b
forall a. a -> a
id
   lift2 :: forall a b c. (T a -> T b -> T c) -> T a -> T b -> T c
lift2 = (T a -> T b -> T c) -> T a -> T b -> T c
forall a. a -> a
id

instance Value Exp where
   lift0 :: forall a. T a -> Exp a
lift0 T a
a = (forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique (T a -> CodeGenFunction r (T a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return T a
a)
   lift1 :: forall a b. (T a -> T b) -> Exp a -> Exp b
lift1 T a -> T b
f (Exp forall r. CodeGenFunction r (T a)
a) = (forall r. CodeGenFunction r (T b)) -> Exp b
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique ((T a -> T b) -> CodeGenFunction r (T a) -> CodeGenFunction r (T b)
forall (m :: * -> *) a r. Monad m => (a -> r) -> m a -> m r
Monad.lift T a -> T b
f CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
a)
   lift2 :: forall a b c. (T a -> T b -> T c) -> Exp a -> Exp b -> Exp c
lift2 T a -> T b -> T c
f (Exp forall r. CodeGenFunction r (T a)
a) (Exp forall r. CodeGenFunction r (T b)
b) = (forall r. CodeGenFunction r (T c)) -> Exp c
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique ((T a -> T b -> T c)
-> CodeGenFunction r (T a)
-> CodeGenFunction r (T b)
-> CodeGenFunction r (T c)
forall (m :: * -> *) a b r.
Monad m =>
(a -> b -> r) -> m a -> m b -> m r
Monad.lift2 T a -> T b -> T c
f CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
a CodeGenFunction r (T b)
forall r. CodeGenFunction r (T b)
b)

lift3 ::
   (Value val) =>
   (MultiValue.T a -> MultiValue.T b -> MultiValue.T c -> MultiValue.T d) ->
   val a -> val b -> val c -> val d
lift3 :: forall (val :: * -> *) a b c d.
Value val =>
(T a -> T b -> T c -> T d) -> val a -> val b -> val c -> val d
lift3 T a -> T b -> T c -> T d
f val a
a val b
b = (T (a, b) -> T c -> T d) -> val (a, b) -> val c -> val d
forall a b c. (T a -> T b -> T c) -> val a -> val b -> val c
forall (val :: * -> *) a b c.
Value val =>
(T a -> T b -> T c) -> val a -> val b -> val c
lift2 ((T a -> T b -> T c -> T d) -> T (a, b) -> T c -> T d
forall a b c. (T a -> T b -> c) -> T (a, b) -> c
MultiValue.uncurry T a -> T b -> T c -> T d
f) (val a -> val b -> val (a, b)
forall (val :: * -> *) a b.
Value val =>
val a -> val b -> val (a, b)
zip val a
a val b
b)

lift4 ::
   (Value val) =>
   (MultiValue.T a -> MultiValue.T b -> MultiValue.T c -> MultiValue.T d ->
    MultiValue.T e) ->
   val a -> val b -> val c -> val d -> val e
lift4 :: forall (val :: * -> *) a b c d e.
Value val =>
(T a -> T b -> T c -> T d -> T e)
-> val a -> val b -> val c -> val d -> val e
lift4 T a -> T b -> T c -> T d -> T e
f val a
a val b
b = (T (a, b) -> T c -> T d -> T e)
-> val (a, b) -> val c -> val d -> val e
forall (val :: * -> *) a b c d.
Value val =>
(T a -> T b -> T c -> T d) -> val a -> val b -> val c -> val d
lift3 ((T a -> T b -> T c -> T d -> T e) -> T (a, b) -> T c -> T d -> T e
forall a b c. (T a -> T b -> c) -> T (a, b) -> c
MultiValue.uncurry T a -> T b -> T c -> T d -> T e
f) (val a -> val b -> val (a, b)
forall (val :: * -> *) a b.
Value val =>
val a -> val b -> val (a, b)
zip val a
a val b
b)



liftM ::
   (Aggregate ae am) =>
   (forall r.
    am -> LLVM.CodeGenFunction r (MultiValue.T b)) ->
   (ae -> Exp b)
liftM :: forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM forall r. am -> CodeGenFunction r (T b)
f ae
a = (forall r. CodeGenFunction r (T b)) -> Exp b
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique (am -> CodeGenFunction r (T b)
forall r. am -> CodeGenFunction r (T b)
f (am -> CodeGenFunction r (T b))
-> CodeGenFunction r am -> CodeGenFunction r (T b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ae -> CodeGenFunction r am
forall r. ae -> CodeGenFunction r am
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ae
a)

liftM2 ::
   (Aggregate ae am) =>
   (Aggregate be bm) =>
   (forall r.
    am -> bm -> LLVM.CodeGenFunction r (MultiValue.T c)) ->
   (ae -> be -> Exp c)
liftM2 :: forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 forall r. am -> bm -> CodeGenFunction r (T c)
f ae
a be
b = (forall r. CodeGenFunction r (T c)) -> Exp c
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique ((am -> bm -> CodeGenFunction r (T c))
-> CodeGenFunction r am
-> CodeGenFunction r bm
-> CodeGenFunction r (T c)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
Monad.liftJoin2 am -> bm -> CodeGenFunction r (T c)
forall r. am -> bm -> CodeGenFunction r (T c)
f (ae -> CodeGenFunction r am
forall r. ae -> CodeGenFunction r am
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ae
a) (be -> CodeGenFunction r bm
forall r. be -> CodeGenFunction r bm
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle be
b))

liftM3 ::
   (Aggregate ae am) =>
   (Aggregate be bm) =>
   (Aggregate ce cm) =>
   (forall r.
    am -> bm -> cm -> LLVM.CodeGenFunction r (MultiValue.T d)) ->
   (ae -> be -> ce -> Exp d)
liftM3 :: forall ae am be bm ce cm d.
(Aggregate ae am, Aggregate be bm, Aggregate ce cm) =>
(forall r. am -> bm -> cm -> CodeGenFunction r (T d))
-> ae -> be -> ce -> Exp d
liftM3 forall r. am -> bm -> cm -> CodeGenFunction r (T d)
f ae
a be
b ce
c = (forall r. CodeGenFunction r (T d)) -> Exp d
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique ((am -> bm -> cm -> CodeGenFunction r (T d))
-> CodeGenFunction r am
-> CodeGenFunction r bm
-> CodeGenFunction r cm
-> CodeGenFunction r (T d)
forall (m :: * -> *) a b c d.
Monad m =>
(a -> b -> c -> m d) -> m a -> m b -> m c -> m d
Monad.liftJoin3 am -> bm -> cm -> CodeGenFunction r (T d)
forall r. am -> bm -> cm -> CodeGenFunction r (T d)
f (ae -> CodeGenFunction r am
forall r. ae -> CodeGenFunction r am
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ae
a) (be -> CodeGenFunction r bm
forall r. be -> CodeGenFunction r bm
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle be
b) (ce -> CodeGenFunction r cm
forall r. ce -> CodeGenFunction r cm
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ce
c))


unliftM1 ::
   (Aggregate ae am) =>
   (Aggregate be bm) =>
   (ae -> be) ->
   am -> LLVM.CodeGenFunction r bm
unliftM1 :: forall ae am be bm r.
(Aggregate ae am, Aggregate be bm) =>
(ae -> be) -> am -> CodeGenFunction r bm
unliftM1 ae -> be
f am
ix = be -> CodeGenFunction r bm
forall r. be -> CodeGenFunction r bm
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle (ae -> be
f (am -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect am
ix))

unliftM2 ::
   (Aggregate ae am) =>
   (Aggregate be bm) =>
   (Aggregate ce cm) =>
   (ae -> be -> ce) ->
   am -> bm -> LLVM.CodeGenFunction r cm
unliftM2 :: forall ae am be bm ce cm r.
(Aggregate ae am, Aggregate be bm, Aggregate ce cm) =>
(ae -> be -> ce) -> am -> bm -> CodeGenFunction r cm
unliftM2 ae -> be -> ce
f am
ix bm
jx = ce -> CodeGenFunction r cm
forall r. ce -> CodeGenFunction r cm
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle (ae -> be -> ce
f (am -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect am
ix) (bm -> be
forall exp mv. Aggregate exp mv => mv -> exp
dissect bm
jx))

unliftM3 ::
   (Aggregate ae am) =>
   (Aggregate be bm) =>
   (Aggregate ce cm) =>
   (Aggregate de dm) =>
   (ae -> be -> ce -> de) ->
   am -> bm -> cm -> LLVM.CodeGenFunction r dm
unliftM3 :: forall ae am be bm ce cm de dm r.
(Aggregate ae am, Aggregate be bm, Aggregate ce cm,
 Aggregate de dm) =>
(ae -> be -> ce -> de) -> am -> bm -> cm -> CodeGenFunction r dm
unliftM3 ae -> be -> ce -> de
f am
ix bm
jx cm
kx = de -> CodeGenFunction r dm
forall r. de -> CodeGenFunction r dm
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle (ae -> be -> ce -> de
f (am -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect am
ix) (bm -> be
forall exp mv. Aggregate exp mv => mv -> exp
dissect bm
jx) (cm -> ce
forall exp mv. Aggregate exp mv => mv -> exp
dissect cm
kx))

unliftM4 ::
   (Aggregate ae am) =>
   (Aggregate be bm) =>
   (Aggregate ce cm) =>
   (Aggregate de dm) =>
   (Aggregate ee em) =>
   (ae -> be -> ce -> de -> ee) ->
   am -> bm -> cm -> dm -> LLVM.CodeGenFunction r em
unliftM4 :: forall ae am be bm ce cm de dm ee em r.
(Aggregate ae am, Aggregate be bm, Aggregate ce cm,
 Aggregate de dm, Aggregate ee em) =>
(ae -> be -> ce -> de -> ee)
-> am -> bm -> cm -> dm -> CodeGenFunction r em
unliftM4 ae -> be -> ce -> de -> ee
f am
ix bm
jx cm
kx dm
lx =
   ee -> CodeGenFunction r em
forall r. ee -> CodeGenFunction r em
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle (ae -> be -> ce -> de -> ee
f (am -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect am
ix) (bm -> be
forall exp mv. Aggregate exp mv => mv -> exp
dissect bm
jx) (cm -> ce
forall exp mv. Aggregate exp mv => mv -> exp
dissect cm
kx) (dm -> de
forall exp mv. Aggregate exp mv => mv -> exp
dissect dm
lx))


liftReprM ::
   (forall r.
    MultiValue.Repr a ->
    LLVM.CodeGenFunction r (MultiValue.Repr b)) ->
   (Exp a -> Exp b)
liftReprM :: forall a b.
(forall r. Repr a -> CodeGenFunction r (Repr b)) -> Exp a -> Exp b
liftReprM forall r. Repr a -> CodeGenFunction r (Repr b)
f = (forall r. T a -> CodeGenFunction r (T b)) -> Exp a -> Exp b
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((Repr a -> CodeGenFunction r (Repr b))
-> T a -> CodeGenFunction r (T b)
forall (m :: * -> *) a b.
Monad m =>
(Repr a -> m (Repr b)) -> T a -> m (T b)
MultiValue.liftM Repr a -> CodeGenFunction r (Repr b)
forall r. Repr a -> CodeGenFunction r (Repr b)
f)

liftReprM2 ::
   (forall r.
    MultiValue.Repr a -> MultiValue.Repr b ->
    LLVM.CodeGenFunction r (MultiValue.Repr c)) ->
   (Exp a -> Exp b -> Exp c)
liftReprM2 :: forall a b c.
(forall r. Repr a -> Repr b -> CodeGenFunction r (Repr c))
-> Exp a -> Exp b -> Exp c
liftReprM2 forall r. Repr a -> Repr b -> CodeGenFunction r (Repr c)
f = (forall r. T a -> T b -> CodeGenFunction r (T c))
-> Exp a -> Exp b -> Exp c
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 ((Repr a -> Repr b -> CodeGenFunction r (Repr c))
-> T a -> T b -> CodeGenFunction r (T c)
forall (m :: * -> *) a b c.
Monad m =>
(Repr a -> Repr b -> m (Repr c)) -> T a -> T b -> m (T c)
MultiValue.liftM2 Repr a -> Repr b -> CodeGenFunction r (Repr c)
forall r. Repr a -> Repr b -> CodeGenFunction r (Repr c)
f)

liftReprM3 ::
   (forall r.
    MultiValue.Repr a -> MultiValue.Repr b -> MultiValue.Repr c ->
    LLVM.CodeGenFunction r (MultiValue.Repr d)) ->
   (Exp a -> Exp b -> Exp c -> Exp d)
liftReprM3 :: forall a b c d.
(forall r.
 Repr a -> Repr b -> Repr c -> CodeGenFunction r (Repr d))
-> Exp a -> Exp b -> Exp c -> Exp d
liftReprM3 forall r. Repr a -> Repr b -> Repr c -> CodeGenFunction r (Repr d)
f = (forall r. T a -> T b -> T c -> CodeGenFunction r (T d))
-> Exp a -> Exp b -> Exp c -> Exp d
forall ae am be bm ce cm d.
(Aggregate ae am, Aggregate be bm, Aggregate ce cm) =>
(forall r. am -> bm -> cm -> CodeGenFunction r (T d))
-> ae -> be -> ce -> Exp d
liftM3 ((Repr a -> Repr b -> Repr c -> CodeGenFunction r (Repr d))
-> T a -> T b -> T c -> CodeGenFunction r (T d)
forall (m :: * -> *) a b c d.
Monad m =>
(Repr a -> Repr b -> Repr c -> m (Repr d))
-> T a -> T b -> T c -> m (T d)
MultiValue.liftM3 Repr a -> Repr b -> Repr c -> CodeGenFunction r (Repr d)
forall r. Repr a -> Repr b -> Repr c -> CodeGenFunction r (Repr d)
f)



zip :: (Value val) => val a -> val b -> val (a, b)
zip :: forall (val :: * -> *) a b.
Value val =>
val a -> val b -> val (a, b)
zip = (T a -> T b -> T (a, b)) -> val a -> val b -> val (a, b)
forall a b c. (T a -> T b -> T c) -> val a -> val b -> val c
forall (val :: * -> *) a b c.
Value val =>
(T a -> T b -> T c) -> val a -> val b -> val c
lift2 T a -> T b -> T (a, b)
forall a b. T a -> T b -> T (a, b)
MultiValue.zip

zip3 :: (Value val) => val a -> val b -> val c -> val (a, b, c)
zip3 :: forall (val :: * -> *) a b c.
Value val =>
val a -> val b -> val c -> val (a, b, c)
zip3 = (T a -> T b -> T c -> T (a, b, c))
-> val a -> val b -> val c -> val (a, b, c)
forall (val :: * -> *) a b c d.
Value val =>
(T a -> T b -> T c -> T d) -> val a -> val b -> val c -> val d
lift3 T a -> T b -> T c -> T (a, b, c)
forall a b c. T a -> T b -> T c -> T (a, b, c)
MultiValue.zip3

zip4 :: (Value val) => val a -> val b -> val c -> val d -> val (a, b, c, d)
zip4 :: forall (val :: * -> *) a b c d.
Value val =>
val a -> val b -> val c -> val d -> val (a, b, c, d)
zip4 = (T a -> T b -> T c -> T d -> T (a, b, c, d))
-> val a -> val b -> val c -> val d -> val (a, b, c, d)
forall (val :: * -> *) a b c d e.
Value val =>
(T a -> T b -> T c -> T d -> T e)
-> val a -> val b -> val c -> val d -> val e
lift4 T a -> T b -> T c -> T d -> T (a, b, c, d)
forall a b c d. T a -> T b -> T c -> T d -> T (a, b, c, d)
MultiValue.zip4

unzip :: (Value val) => val (a, b) -> (val a, val b)
unzip :: forall (val :: * -> *) a b.
Value val =>
val (a, b) -> (val a, val b)
unzip val (a, b)
ab = (val (a, b) -> val a
forall (val :: * -> *) a b. Value val => val (a, b) -> val a
fst val (a, b)
ab, val (a, b) -> val b
forall (val :: * -> *) a b. Value val => val (a, b) -> val b
snd val (a, b)
ab)

unzip3 :: (Value val) => val (a, b, c) -> (val a, val b, val c)
unzip3 :: forall (val :: * -> *) a b c.
Value val =>
val (a, b, c) -> (val a, val b, val c)
unzip3 val (a, b, c)
abc = (val (a, b, c) -> val a
forall (val :: * -> *) a b c. Value val => val (a, b, c) -> val a
fst3 val (a, b, c)
abc, val (a, b, c) -> val b
forall (val :: * -> *) a b c. Value val => val (a, b, c) -> val b
snd3 val (a, b, c)
abc, val (a, b, c) -> val c
forall (val :: * -> *) a b c. Value val => val (a, b, c) -> val c
thd3 val (a, b, c)
abc)

unzip4 :: (Value val) => val (a, b, c, d) -> (val a, val b, val c, val d)
unzip4 :: forall (val :: * -> *) a b c d.
Value val =>
val (a, b, c, d) -> (val a, val b, val c, val d)
unzip4 val (a, b, c, d)
abcd =
   ((T (a, b, c, d) -> T a) -> val (a, b, c, d) -> val a
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 (\(MultiValue.Cons (Repr a
a,Repr b
_,Repr c
_,Repr d
_)) -> Repr a -> T a
forall a. Repr a -> T a
MultiValue.Cons Repr a
a) val (a, b, c, d)
abcd,
    (T (a, b, c, d) -> T b) -> val (a, b, c, d) -> val b
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 (\(MultiValue.Cons (Repr a
_,Repr b
b,Repr c
_,Repr d
_)) -> Repr b -> T b
forall a. Repr a -> T a
MultiValue.Cons Repr b
b) val (a, b, c, d)
abcd,
    (T (a, b, c, d) -> T c) -> val (a, b, c, d) -> val c
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 (\(MultiValue.Cons (Repr a
_,Repr b
_,Repr c
c,Repr d
_)) -> Repr c -> T c
forall a. Repr a -> T a
MultiValue.Cons Repr c
c) val (a, b, c, d)
abcd,
    (T (a, b, c, d) -> T d) -> val (a, b, c, d) -> val d
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 (\(MultiValue.Cons (Repr a
_,Repr b
_,Repr c
_,Repr d
d)) -> Repr d -> T d
forall a. Repr a -> T a
MultiValue.Cons Repr d
d) val (a, b, c, d)
abcd)


fst :: (Value val) => val (a, b) -> val a
fst :: forall (val :: * -> *) a b. Value val => val (a, b) -> val a
fst = (T (a, b) -> T a) -> val (a, b) -> val a
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 T (a, b) -> T a
forall a b. T (a, b) -> T a
MultiValue.fst

snd :: (Value val) => val (a, b) -> val b
snd :: forall (val :: * -> *) a b. Value val => val (a, b) -> val b
snd = (T (a, b) -> T b) -> val (a, b) -> val b
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 T (a, b) -> T b
forall a b. T (a, b) -> T b
MultiValue.snd

mapFst :: (Exp a -> Exp b) -> Exp (a, c) -> Exp (b, c)
mapFst :: forall a b c. (Exp a -> Exp b) -> Exp (a, c) -> Exp (b, c)
mapFst Exp a -> Exp b
f = (forall r. T (a, c) -> CodeGenFunction r (T (b, c)))
-> Exp (a, c) -> Exp (b, c)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((T a -> CodeGenFunction r (T b))
-> T (a, c) -> CodeGenFunction r (T (b, c))
forall (f :: * -> *) a0 a1 b.
Functor f =>
(T a0 -> f (T a1)) -> T (a0, b) -> f (T (a1, b))
MultiValue.mapFstF ((Exp a -> Exp b) -> T a -> CodeGenFunction r (T b)
forall ae am be bm r.
(Aggregate ae am, Aggregate be bm) =>
(ae -> be) -> am -> CodeGenFunction r bm
unliftM1 Exp a -> Exp b
f))

mapSnd :: (Exp b -> Exp c) -> Exp (a, b) -> Exp (a, c)
mapSnd :: forall b c a. (Exp b -> Exp c) -> Exp (a, b) -> Exp (a, c)
mapSnd Exp b -> Exp c
f = (forall r. T (a, b) -> CodeGenFunction r (T (a, c)))
-> Exp (a, b) -> Exp (a, c)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((T b -> CodeGenFunction r (T c))
-> T (a, b) -> CodeGenFunction r (T (a, c))
forall (f :: * -> *) b0 b1 a.
Functor f =>
(T b0 -> f (T b1)) -> T (a, b0) -> f (T (a, b1))
MultiValue.mapSndF ((Exp b -> Exp c) -> T b -> CodeGenFunction r (T c)
forall ae am be bm r.
(Aggregate ae am, Aggregate be bm) =>
(ae -> be) -> am -> CodeGenFunction r bm
unliftM1 Exp b -> Exp c
f))

mapPair :: (Exp a0 -> Exp a1, Exp b0 -> Exp b1) -> Exp (a0, b0) -> Exp (a1, b1)
mapPair :: forall a0 a1 b0 b1.
(Exp a0 -> Exp a1, Exp b0 -> Exp b1)
-> Exp (a0, b0) -> Exp (a1, b1)
mapPair (Exp a0 -> Exp a1
f,Exp b0 -> Exp b1
g) = (Exp a0 -> Exp a1) -> Exp (a0, b1) -> Exp (a1, b1)
forall a b c. (Exp a -> Exp b) -> Exp (a, c) -> Exp (b, c)
mapFst Exp a0 -> Exp a1
f (Exp (a0, b1) -> Exp (a1, b1))
-> (Exp (a0, b0) -> Exp (a0, b1)) -> Exp (a0, b0) -> Exp (a1, b1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exp b0 -> Exp b1) -> Exp (a0, b0) -> Exp (a0, b1)
forall b c a. (Exp b -> Exp c) -> Exp (a, b) -> Exp (a, c)
mapSnd Exp b0 -> Exp b1
g

swap :: (Value val) => val (a, b) -> val (b, a)
swap :: forall (val :: * -> *) a b. Value val => val (a, b) -> val (b, a)
swap = (T (a, b) -> T (b, a)) -> val (a, b) -> val (b, a)
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 T (a, b) -> T (b, a)
forall a b. T (a, b) -> T (b, a)
MultiValue.swap

curry :: (Exp (a,b) -> c) -> (Exp a -> Exp b -> c)
curry :: forall a b c. (Exp (a, b) -> c) -> Exp a -> Exp b -> c
curry Exp (a, b) -> c
f = ((Exp a, Exp b) -> c) -> Exp a -> Exp b -> c
forall a b c. ((a, b) -> c) -> a -> b -> c
Tuple.curry (Exp (a, b) -> c
f (Exp (a, b) -> c)
-> ((Exp a, Exp b) -> Exp (a, b)) -> (Exp a, Exp b) -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exp a -> Exp b -> Exp (a, b)) -> (Exp a, Exp b) -> Exp (a, b)
forall a b c. (a -> b -> c) -> (a, b) -> c
Tuple.uncurry Exp a -> Exp b -> Exp (a, b)
forall (val :: * -> *) a b.
Value val =>
val a -> val b -> val (a, b)
zip)

uncurry :: (Exp a -> Exp b -> c) -> (Exp (a,b) -> c)
uncurry :: forall a b c. (Exp a -> Exp b -> c) -> Exp (a, b) -> c
uncurry Exp a -> Exp b -> c
f = (Exp a -> Exp b -> c) -> (Exp a, Exp b) -> c
forall a b c. (a -> b -> c) -> (a, b) -> c
Tuple.uncurry Exp a -> Exp b -> c
f ((Exp a, Exp b) -> c)
-> (Exp (a, b) -> (Exp a, Exp b)) -> Exp (a, b) -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (a, b) -> (Exp a, Exp b)
forall (val :: * -> *) a b.
Value val =>
val (a, b) -> (val a, val b)
unzip


fst3 :: (Value val) => val (a,b,c) -> val a
fst3 :: forall (val :: * -> *) a b c. Value val => val (a, b, c) -> val a
fst3 = (T (a, b, c) -> T a) -> val (a, b, c) -> val a
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 T (a, b, c) -> T a
forall a b c. T (a, b, c) -> T a
MultiValue.fst3

snd3 :: (Value val) => val (a,b,c) -> val b
snd3 :: forall (val :: * -> *) a b c. Value val => val (a, b, c) -> val b
snd3 = (T (a, b, c) -> T b) -> val (a, b, c) -> val b
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 T (a, b, c) -> T b
forall a b c. T (a, b, c) -> T b
MultiValue.snd3

thd3 :: (Value val) => val (a,b,c) -> val c
thd3 :: forall (val :: * -> *) a b c. Value val => val (a, b, c) -> val c
thd3 = (T (a, b, c) -> T c) -> val (a, b, c) -> val c
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 T (a, b, c) -> T c
forall a b c. T (a, b, c) -> T c
MultiValue.thd3

mapFst3 :: (Exp a0 -> Exp a1) -> Exp (a0,b,c) -> Exp (a1,b,c)
mapFst3 :: forall a0 a1 b c.
(Exp a0 -> Exp a1) -> Exp (a0, b, c) -> Exp (a1, b, c)
mapFst3 Exp a0 -> Exp a1
f = (forall r. T (a0, b, c) -> CodeGenFunction r (T (a1, b, c)))
-> Exp (a0, b, c) -> Exp (a1, b, c)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((T a0 -> CodeGenFunction r (T a1))
-> T (a0, b, c) -> CodeGenFunction r (T (a1, b, c))
forall (f :: * -> *) a0 a1 b c.
Functor f =>
(T a0 -> f (T a1)) -> T (a0, b, c) -> f (T (a1, b, c))
MultiValue.mapFst3F ((Exp a0 -> Exp a1) -> T a0 -> CodeGenFunction r (T a1)
forall ae am be bm r.
(Aggregate ae am, Aggregate be bm) =>
(ae -> be) -> am -> CodeGenFunction r bm
unliftM1 Exp a0 -> Exp a1
f))

mapSnd3 :: (Exp b0 -> Exp b1) -> Exp (a,b0,c) -> Exp (a,b1,c)
mapSnd3 :: forall b0 b1 a c.
(Exp b0 -> Exp b1) -> Exp (a, b0, c) -> Exp (a, b1, c)
mapSnd3 Exp b0 -> Exp b1
f = (forall r. T (a, b0, c) -> CodeGenFunction r (T (a, b1, c)))
-> Exp (a, b0, c) -> Exp (a, b1, c)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((T b0 -> CodeGenFunction r (T b1))
-> T (a, b0, c) -> CodeGenFunction r (T (a, b1, c))
forall (f :: * -> *) b0 b1 a c.
Functor f =>
(T b0 -> f (T b1)) -> T (a, b0, c) -> f (T (a, b1, c))
MultiValue.mapSnd3F ((Exp b0 -> Exp b1) -> T b0 -> CodeGenFunction r (T b1)
forall ae am be bm r.
(Aggregate ae am, Aggregate be bm) =>
(ae -> be) -> am -> CodeGenFunction r bm
unliftM1 Exp b0 -> Exp b1
f))

mapThd3 :: (Exp c0 -> Exp c1) -> Exp (a,b,c0) -> Exp (a,b,c1)
mapThd3 :: forall c0 c1 a b.
(Exp c0 -> Exp c1) -> Exp (a, b, c0) -> Exp (a, b, c1)
mapThd3 Exp c0 -> Exp c1
f = (forall r. T (a, b, c0) -> CodeGenFunction r (T (a, b, c1)))
-> Exp (a, b, c0) -> Exp (a, b, c1)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((T c0 -> CodeGenFunction r (T c1))
-> T (a, b, c0) -> CodeGenFunction r (T (a, b, c1))
forall (f :: * -> *) c0 c1 a b.
Functor f =>
(T c0 -> f (T c1)) -> T (a, b, c0) -> f (T (a, b, c1))
MultiValue.mapThd3F ((Exp c0 -> Exp c1) -> T c0 -> CodeGenFunction r (T c1)
forall ae am be bm r.
(Aggregate ae am, Aggregate be bm) =>
(ae -> be) -> am -> CodeGenFunction r bm
unliftM1 Exp c0 -> Exp c1
f))

mapTriple ::
   (Exp a0 -> Exp a1, Exp b0 -> Exp b1, Exp c0 -> Exp c1) ->
   Exp (a0,b0,c0) -> Exp (a1,b1,c1)
mapTriple :: forall a0 a1 b0 b1 c0 c1.
(Exp a0 -> Exp a1, Exp b0 -> Exp b1, Exp c0 -> Exp c1)
-> Exp (a0, b0, c0) -> Exp (a1, b1, c1)
mapTriple (Exp a0 -> Exp a1
f,Exp b0 -> Exp b1
g,Exp c0 -> Exp c1
h) = (Exp a0 -> Exp a1) -> Exp (a0, b1, c1) -> Exp (a1, b1, c1)
forall a0 a1 b c.
(Exp a0 -> Exp a1) -> Exp (a0, b, c) -> Exp (a1, b, c)
mapFst3 Exp a0 -> Exp a1
f (Exp (a0, b1, c1) -> Exp (a1, b1, c1))
-> (Exp (a0, b0, c0) -> Exp (a0, b1, c1))
-> Exp (a0, b0, c0)
-> Exp (a1, b1, c1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exp b0 -> Exp b1) -> Exp (a0, b0, c1) -> Exp (a0, b1, c1)
forall b0 b1 a c.
(Exp b0 -> Exp b1) -> Exp (a, b0, c) -> Exp (a, b1, c)
mapSnd3 Exp b0 -> Exp b1
g (Exp (a0, b0, c1) -> Exp (a0, b1, c1))
-> (Exp (a0, b0, c0) -> Exp (a0, b0, c1))
-> Exp (a0, b0, c0)
-> Exp (a0, b1, c1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exp c0 -> Exp c1) -> Exp (a0, b0, c0) -> Exp (a0, b0, c1)
forall c0 c1 a b.
(Exp c0 -> Exp c1) -> Exp (a, b, c0) -> Exp (a, b, c1)
mapThd3 Exp c0 -> Exp c1
h


tuple :: Exp tuple -> Exp (StTuple.Tuple tuple)
tuple :: forall tuple. Exp tuple -> Exp (Tuple tuple)
tuple = (T tuple -> T (Tuple tuple)) -> Exp tuple -> Exp (Tuple tuple)
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
lift1 T tuple -> T (Tuple tuple)
forall tuple. T tuple -> T (Tuple tuple)
MultiValue.tuple

untuple :: Exp (StTuple.Tuple tuple) -> Exp tuple
untuple :: forall tuple. Exp (Tuple tuple) -> Exp tuple
untuple = (T (Tuple tuple) -> T tuple) -> Exp (Tuple tuple) -> Exp tuple
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
lift1 T (Tuple tuple) -> T tuple
forall tuple. T (Tuple tuple) -> T tuple
MultiValue.untuple


modifyMultiValue ::
   (Value val,
    MultiValue.Compose a,
    MultiValue.Decompose pattern,
    MultiValue.PatternTuple pattern ~ tuple) =>
   pattern ->
   (Decomposed MultiValue.T pattern -> a) ->
   val tuple -> val (MultiValue.Composed a)
modifyMultiValue :: forall (val :: * -> *) a pattern tuple.
(Value val, Compose a, Decompose pattern,
 PatternTuple pattern ~ tuple) =>
pattern
-> (Decomposed T pattern -> a) -> val tuple -> val (Composed a)
modifyMultiValue pattern
p Decomposed T pattern -> a
f = (T tuple -> T (Composed a)) -> val tuple -> val (Composed a)
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
lift1 ((T tuple -> T (Composed a)) -> val tuple -> val (Composed a))
-> (T tuple -> T (Composed a)) -> val tuple -> val (Composed a)
forall a b. (a -> b) -> a -> b
$ pattern
-> (Decomposed T pattern -> a)
-> T (PatternTuple pattern)
-> T (Composed a)
forall a pattern.
(Compose a, Decompose pattern) =>
pattern
-> (Decomposed T pattern -> a)
-> T (PatternTuple pattern)
-> T (Composed a)
MultiValue.modify pattern
p Decomposed T pattern -> a
f

modifyMultiValue2 ::
   (Value val,
    MultiValue.Compose a,
    MultiValue.Decompose patternA,
    MultiValue.Decompose patternB,
    MultiValue.PatternTuple patternA ~ tupleA,
    MultiValue.PatternTuple patternB ~ tupleB) =>
   patternA ->
   patternB ->
   (Decomposed MultiValue.T patternA ->
    Decomposed MultiValue.T patternB -> a) ->
   val tupleA -> val tupleB -> val (MultiValue.Composed a)
modifyMultiValue2 :: forall (val :: * -> *) a patternA patternB tupleA tupleB.
(Value val, Compose a, Decompose patternA, Decompose patternB,
 PatternTuple patternA ~ tupleA, PatternTuple patternB ~ tupleB) =>
patternA
-> patternB
-> (Decomposed T patternA -> Decomposed T patternB -> a)
-> val tupleA
-> val tupleB
-> val (Composed a)
modifyMultiValue2 patternA
pa patternB
pb Decomposed T patternA -> Decomposed T patternB -> a
f = (T tupleA -> T tupleB -> T (Composed a))
-> val tupleA -> val tupleB -> val (Composed a)
forall a b c. (T a -> T b -> T c) -> val a -> val b -> val c
forall (val :: * -> *) a b c.
Value val =>
(T a -> T b -> T c) -> val a -> val b -> val c
lift2 ((T tupleA -> T tupleB -> T (Composed a))
 -> val tupleA -> val tupleB -> val (Composed a))
-> (T tupleA -> T tupleB -> T (Composed a))
-> val tupleA
-> val tupleB
-> val (Composed a)
forall a b. (a -> b) -> a -> b
$ patternA
-> patternB
-> (Decomposed T patternA -> Decomposed T patternB -> a)
-> T (PatternTuple patternA)
-> T (PatternTuple patternB)
-> T (Composed a)
forall a patternA patternB.
(Compose a, Decompose patternA, Decompose patternB) =>
patternA
-> patternB
-> (Decomposed T patternA -> Decomposed T patternB -> a)
-> T (PatternTuple patternA)
-> T (PatternTuple patternB)
-> T (Composed a)
MultiValue.modify2 patternA
pa patternB
pb Decomposed T patternA -> Decomposed T patternB -> a
f

modifyMultiValueM ::
   (MultiValue.Compose a,
    MultiValue.Decompose pattern,
    MultiValue.PatternTuple pattern ~ tuple) =>
   pattern ->
   (forall r.
    Decomposed MultiValue.T pattern ->
    LLVM.CodeGenFunction r a) ->
   Exp tuple -> Exp (MultiValue.Composed a)
modifyMultiValueM :: forall a pattern tuple.
(Compose a, Decompose pattern, PatternTuple pattern ~ tuple) =>
pattern
-> (forall r. Decomposed T pattern -> CodeGenFunction r a)
-> Exp tuple
-> Exp (Composed a)
modifyMultiValueM pattern
p forall r. Decomposed T pattern -> CodeGenFunction r a
f = (forall r. T tuple -> CodeGenFunction r (T (Composed a)))
-> Exp tuple -> Exp (Composed a)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM (pattern
-> (Decomposed T pattern -> CodeGenFunction r a)
-> T (PatternTuple pattern)
-> CodeGenFunction r (T (Composed a))
forall a pattern (f :: * -> *).
(Compose a, Decompose pattern, Functor f) =>
pattern
-> (Decomposed T pattern -> f a)
-> T (PatternTuple pattern)
-> f (T (Composed a))
MultiValue.modifyF pattern
p Decomposed T pattern -> CodeGenFunction r a
forall r. Decomposed T pattern -> CodeGenFunction r a
f)

modifyMultiValueM2 ::
   (MultiValue.Compose a,
    MultiValue.Decompose patternA,
    MultiValue.Decompose patternB,
    MultiValue.PatternTuple patternA ~ tupleA,
    MultiValue.PatternTuple patternB ~ tupleB) =>
   patternA ->
   patternB ->
   (forall r.
    Decomposed MultiValue.T patternA ->
    Decomposed MultiValue.T patternB ->
    LLVM.CodeGenFunction r a) ->
   Exp tupleA -> Exp tupleB -> Exp (MultiValue.Composed a)
modifyMultiValueM2 :: forall a patternA patternB tupleA tupleB.
(Compose a, Decompose patternA, Decompose patternB,
 PatternTuple patternA ~ tupleA, PatternTuple patternB ~ tupleB) =>
patternA
-> patternB
-> (forall r.
    Decomposed T patternA
    -> Decomposed T patternB -> CodeGenFunction r a)
-> Exp tupleA
-> Exp tupleB
-> Exp (Composed a)
modifyMultiValueM2 patternA
pa patternB
pb forall r.
Decomposed T patternA
-> Decomposed T patternB -> CodeGenFunction r a
f = (forall r.
 T tupleA -> T tupleB -> CodeGenFunction r (T (Composed a)))
-> Exp tupleA -> Exp tupleB -> Exp (Composed a)
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 (patternA
-> patternB
-> (Decomposed T patternA
    -> Decomposed T patternB -> CodeGenFunction r a)
-> T (PatternTuple patternA)
-> T (PatternTuple patternB)
-> CodeGenFunction r (T (Composed a))
forall a patternA patternB (f :: * -> *).
(Compose a, Decompose patternA, Decompose patternB, Functor f) =>
patternA
-> patternB
-> (Decomposed T patternA -> Decomposed T patternB -> f a)
-> T (PatternTuple patternA)
-> T (PatternTuple patternB)
-> f (T (Composed a))
MultiValue.modifyF2 patternA
pa patternB
pb Decomposed T patternA
-> Decomposed T patternB -> CodeGenFunction r a
forall r.
Decomposed T patternA
-> Decomposed T patternB -> CodeGenFunction r a
f)


class Compose multituple where
   type Composed multituple
   {- |
   A nested 'zip'.
   -}
   compose :: multituple -> Exp (Composed multituple)

class
   (Composed (Decomposed Exp pattern) ~ PatternTuple pattern) =>
      Decompose pattern where
   {- |
   Analogous to 'MultiValue.decompose'.
   -}
   decompose :: pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern


{- |
Analogus to 'MultiValue.modifyMultiValue'.
-}
modify ::
   (Compose a, Decompose pattern) =>
   pattern ->
   (Decomposed Exp pattern -> a) ->
   Exp (PatternTuple pattern) -> Exp (Composed a)
modify :: forall a pattern.
(Compose a, Decompose pattern) =>
pattern
-> (Decomposed Exp pattern -> a)
-> Exp (PatternTuple pattern)
-> Exp (Composed a)
modify pattern
p Decomposed Exp pattern -> a
f = a -> Exp (Composed a)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose (a -> Exp (Composed a))
-> (Exp (PatternTuple pattern) -> a)
-> Exp (PatternTuple pattern)
-> Exp (Composed a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decomposed Exp pattern -> a
f (Decomposed Exp pattern -> a)
-> (Exp (PatternTuple pattern) -> Decomposed Exp pattern)
-> Exp (PatternTuple pattern)
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pattern
p

modify2 ::
   (Compose a, Decompose patternA, Decompose patternB) =>
   patternA ->
   patternB ->
   (Decomposed Exp patternA -> Decomposed Exp patternB -> a) ->
   Exp (PatternTuple patternA) ->
   Exp (PatternTuple patternB) -> Exp (Composed a)
modify2 :: forall a patternA patternB.
(Compose a, Decompose patternA, Decompose patternB) =>
patternA
-> patternB
-> (Decomposed Exp patternA -> Decomposed Exp patternB -> a)
-> Exp (PatternTuple patternA)
-> Exp (PatternTuple patternB)
-> Exp (Composed a)
modify2 patternA
pa patternB
pb Decomposed Exp patternA -> Decomposed Exp patternB -> a
f Exp (PatternTuple patternA)
a Exp (PatternTuple patternB)
b = a -> Exp (Composed a)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose (a -> Exp (Composed a)) -> a -> Exp (Composed a)
forall a b. (a -> b) -> a -> b
$ Decomposed Exp patternA -> Decomposed Exp patternB -> a
f (patternA -> Exp (PatternTuple patternA) -> Decomposed Exp patternA
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose patternA
pa Exp (PatternTuple patternA)
a) (patternB -> Exp (PatternTuple patternB) -> Decomposed Exp patternB
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose patternB
pb Exp (PatternTuple patternB)
b)



instance Compose (Exp a) where
   type Composed (Exp a) = a
   compose :: Exp a -> Exp (Composed (Exp a))
compose = Exp a -> Exp a
Exp a -> Exp (Composed (Exp a))
forall a. a -> a
id

instance Decompose (Atom a) where
   decompose :: Atom a -> Exp (PatternTuple (Atom a)) -> Decomposed Exp (Atom a)
decompose Atom a
_ = Exp a -> Exp a
Exp (PatternTuple (Atom a)) -> Decomposed Exp (Atom a)
forall a. a -> a
id



instance Compose () where
   type Composed () = ()
   compose :: () -> Exp (Composed ())
compose = () -> Exp ()
() -> Exp (Composed ())
forall a. C a => a -> Exp a
cons

instance Decompose () where
   decompose :: () -> Exp (PatternTuple ()) -> Decomposed Exp ()
decompose ()
_ Exp (PatternTuple ())
_ = ()


instance (Compose a, Compose b) => Compose (a,b) where
   type Composed (a,b) = (Composed a, Composed b)
   compose :: (a, b) -> Exp (Composed (a, b))
compose = (Exp (Composed a)
 -> Exp (Composed b) -> Exp (Composed a, Composed b))
-> (Exp (Composed a), Exp (Composed b))
-> Exp (Composed a, Composed b)
forall a b c. (a -> b -> c) -> (a, b) -> c
Tuple.uncurry Exp (Composed a)
-> Exp (Composed b) -> Exp (Composed a, Composed b)
forall (val :: * -> *) a b.
Value val =>
val a -> val b -> val (a, b)
zip ((Exp (Composed a), Exp (Composed b))
 -> Exp (Composed a, Composed b))
-> ((a, b) -> (Exp (Composed a), Exp (Composed b)))
-> (a, b)
-> Exp (Composed a, Composed b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Exp (Composed a), b -> Exp (Composed b))
-> (a, b) -> (Exp (Composed a), Exp (Composed b))
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
TupleHT.mapPair (a -> Exp (Composed a)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose, b -> Exp (Composed b)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose)

instance (Decompose pa, Decompose pb) => Decompose (pa,pb) where
   decompose :: (pa, pb) -> Exp (PatternTuple (pa, pb)) -> Decomposed Exp (pa, pb)
decompose (pa
pa,pb
pb) =
      (Exp (PatternTuple pa) -> Decomposed Exp pa,
 Exp (PatternTuple pb) -> Decomposed Exp pb)
-> (Exp (PatternTuple pa), Exp (PatternTuple pb))
-> (Decomposed Exp pa, Decomposed Exp pb)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
TupleHT.mapPair (pa -> Exp (PatternTuple pa) -> Decomposed Exp pa
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pa
pa, pb -> Exp (PatternTuple pb) -> Decomposed Exp pb
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pb
pb) ((Exp (PatternTuple pa), Exp (PatternTuple pb))
 -> (Decomposed Exp pa, Decomposed Exp pb))
-> (Exp (PatternTuple pa, PatternTuple pb)
    -> (Exp (PatternTuple pa), Exp (PatternTuple pb)))
-> Exp (PatternTuple pa, PatternTuple pb)
-> (Decomposed Exp pa, Decomposed Exp pb)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (PatternTuple pa, PatternTuple pb)
-> (Exp (PatternTuple pa), Exp (PatternTuple pb))
forall (val :: * -> *) a b.
Value val =>
val (a, b) -> (val a, val b)
unzip


instance (Compose a, Compose b, Compose c) => Compose (a,b,c) where
   type Composed (a,b,c) = (Composed a, Composed b, Composed c)
   compose :: (a, b, c) -> Exp (Composed (a, b, c))
compose =
      (Exp (Composed a)
 -> Exp (Composed b)
 -> Exp (Composed c)
 -> Exp (Composed a, Composed b, Composed c))
-> (Exp (Composed a), Exp (Composed b), Exp (Composed c))
-> Exp (Composed a, Composed b, Composed c)
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
TupleHT.uncurry3 Exp (Composed a)
-> Exp (Composed b)
-> Exp (Composed c)
-> Exp (Composed a, Composed b, Composed c)
forall (val :: * -> *) a b c.
Value val =>
val a -> val b -> val c -> val (a, b, c)
zip3 ((Exp (Composed a), Exp (Composed b), Exp (Composed c))
 -> Exp (Composed a, Composed b, Composed c))
-> ((a, b, c)
    -> (Exp (Composed a), Exp (Composed b), Exp (Composed c)))
-> (a, b, c)
-> Exp (Composed a, Composed b, Composed c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Exp (Composed a), b -> Exp (Composed b),
 c -> Exp (Composed c))
-> (a, b, c)
-> (Exp (Composed a), Exp (Composed b), Exp (Composed c))
forall a d b e c f.
(a -> d, b -> e, c -> f) -> (a, b, c) -> (d, e, f)
TupleHT.mapTriple (a -> Exp (Composed a)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose, b -> Exp (Composed b)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose, c -> Exp (Composed c)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose)

instance
   (Decompose pa, Decompose pb, Decompose pc) =>
      Decompose (pa,pb,pc) where
   decompose :: (pa, pb, pc)
-> Exp (PatternTuple (pa, pb, pc)) -> Decomposed Exp (pa, pb, pc)
decompose (pa
pa,pb
pb,pc
pc) =
      (Exp (PatternTuple pa) -> Decomposed Exp pa,
 Exp (PatternTuple pb) -> Decomposed Exp pb,
 Exp (PatternTuple pc) -> Decomposed Exp pc)
-> (Exp (PatternTuple pa), Exp (PatternTuple pb),
    Exp (PatternTuple pc))
-> (Decomposed Exp pa, Decomposed Exp pb, Decomposed Exp pc)
forall a d b e c f.
(a -> d, b -> e, c -> f) -> (a, b, c) -> (d, e, f)
TupleHT.mapTriple (pa -> Exp (PatternTuple pa) -> Decomposed Exp pa
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pa
pa, pb -> Exp (PatternTuple pb) -> Decomposed Exp pb
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pb
pb, pc -> Exp (PatternTuple pc) -> Decomposed Exp pc
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pc
pc) ((Exp (PatternTuple pa), Exp (PatternTuple pb),
  Exp (PatternTuple pc))
 -> (Decomposed Exp pa, Decomposed Exp pb, Decomposed Exp pc))
-> (Exp (PatternTuple pa, PatternTuple pb, PatternTuple pc)
    -> (Exp (PatternTuple pa), Exp (PatternTuple pb),
        Exp (PatternTuple pc)))
-> Exp (PatternTuple pa, PatternTuple pb, PatternTuple pc)
-> (Decomposed Exp pa, Decomposed Exp pb, Decomposed Exp pc)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (PatternTuple pa, PatternTuple pb, PatternTuple pc)
-> (Exp (PatternTuple pa), Exp (PatternTuple pb),
    Exp (PatternTuple pc))
forall (val :: * -> *) a b c.
Value val =>
val (a, b, c) -> (val a, val b, val c)
unzip3


instance (Compose a, Compose b, Compose c, Compose d) => Compose (a,b,c,d) where
   type Composed (a,b,c,d) = (Composed a, Composed b, Composed c, Composed d)
   compose :: (a, b, c, d) -> Exp (Composed (a, b, c, d))
compose (a
a,b
b,c
c,d
d) = Exp (Composed a)
-> Exp (Composed b)
-> Exp (Composed c)
-> Exp (Composed d)
-> Exp (Composed a, Composed b, Composed c, Composed d)
forall (val :: * -> *) a b c d.
Value val =>
val a -> val b -> val c -> val d -> val (a, b, c, d)
zip4 (a -> Exp (Composed a)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose a
a) (b -> Exp (Composed b)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose b
b) (c -> Exp (Composed c)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose c
c) (d -> Exp (Composed d)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose d
d)

instance
   (Decompose pa, Decompose pb, Decompose pc, Decompose pd) =>
      Decompose (pa,pb,pc,pd) where
   decompose :: (pa, pb, pc, pd)
-> Exp (PatternTuple (pa, pb, pc, pd))
-> Decomposed Exp (pa, pb, pc, pd)
decompose (pa
pa,pb
pb,pc
pc,pd
pd) Exp (PatternTuple (pa, pb, pc, pd))
x =
      case Exp
  (PatternTuple pa, PatternTuple pb, PatternTuple pc,
   PatternTuple pd)
-> (Exp (PatternTuple pa), Exp (PatternTuple pb),
    Exp (PatternTuple pc), Exp (PatternTuple pd))
forall (val :: * -> *) a b c d.
Value val =>
val (a, b, c, d) -> (val a, val b, val c, val d)
unzip4 Exp
  (PatternTuple pa, PatternTuple pb, PatternTuple pc,
   PatternTuple pd)
Exp (PatternTuple (pa, pb, pc, pd))
x of
         (Exp (PatternTuple pa)
a,Exp (PatternTuple pb)
b,Exp (PatternTuple pc)
c,Exp (PatternTuple pd)
d) ->
            (pa -> Exp (PatternTuple pa) -> Decomposed Exp pa
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pa
pa Exp (PatternTuple pa)
a, pb -> Exp (PatternTuple pb) -> Decomposed Exp pb
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pb
pb Exp (PatternTuple pb)
b, pc -> Exp (PatternTuple pc) -> Decomposed Exp pc
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pc
pc Exp (PatternTuple pc)
c, pd -> Exp (PatternTuple pd) -> Decomposed Exp pd
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose pd
pd Exp (PatternTuple pd)
d)


instance (Compose tuple) => Compose (StTuple.Tuple tuple) where
   type Composed (StTuple.Tuple tuple) = StTuple.Tuple (Composed tuple)
   compose :: Tuple tuple -> Exp (Composed (Tuple tuple))
compose (StTuple.Tuple tuple
tup) = Exp (Composed tuple) -> Exp (Tuple (Composed tuple))
forall tuple. Exp tuple -> Exp (Tuple tuple)
tuple (Exp (Composed tuple) -> Exp (Tuple (Composed tuple)))
-> Exp (Composed tuple) -> Exp (Tuple (Composed tuple))
forall a b. (a -> b) -> a -> b
$ tuple -> Exp (Composed tuple)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose tuple
tup

instance (Decompose p) => Decompose (StTuple.Tuple p) where
   decompose :: Tuple p -> Exp (PatternTuple (Tuple p)) -> Decomposed Exp (Tuple p)
decompose (StTuple.Tuple p
p) = Decomposed Exp p -> Tuple (Decomposed Exp p)
forall a. a -> Tuple a
StTuple.Tuple (Decomposed Exp p -> Tuple (Decomposed Exp p))
-> (Exp (Tuple (PatternTuple p)) -> Decomposed Exp p)
-> Exp (Tuple (PatternTuple p))
-> Tuple (Decomposed Exp p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p -> Exp (PatternTuple p) -> Decomposed Exp p
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose p
p (Exp (PatternTuple p) -> Decomposed Exp p)
-> (Exp (Tuple (PatternTuple p)) -> Exp (PatternTuple p))
-> Exp (Tuple (PatternTuple p))
-> Decomposed Exp p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (Tuple (PatternTuple p)) -> Exp (PatternTuple p)
forall tuple. Exp (Tuple tuple) -> Exp tuple
untuple


instance (Compose a) => Compose (Complex a) where
   type Composed (Complex a) = Complex (Composed a)
   compose :: Complex a -> Exp (Composed (Complex a))
compose (a
r:+a
i) = Exp (Composed a) -> Exp (Composed a) -> Exp (Complex (Composed a))
forall a. Exp a -> Exp a -> Exp (Complex a)
consComplex (a -> Exp (Composed a)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose a
r) (a -> Exp (Composed a)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
compose a
i)

instance (Decompose p) => Decompose (Complex p) where
   decompose :: Complex p
-> Exp (PatternTuple (Complex p)) -> Decomposed Exp (Complex p)
decompose (p
pr:+p
pi) =
      (Decomposed Exp p
 -> Decomposed Exp p -> Complex (Decomposed Exp p))
-> (Decomposed Exp p, Decomposed Exp p)
-> Complex (Decomposed Exp p)
forall a b c. (a -> b -> c) -> (a, b) -> c
Tuple.uncurry Decomposed Exp p -> Decomposed Exp p -> Complex (Decomposed Exp p)
forall a. a -> a -> Complex a
(:+) ((Decomposed Exp p, Decomposed Exp p)
 -> Complex (Decomposed Exp p))
-> (Exp (Complex (PatternTuple p))
    -> (Decomposed Exp p, Decomposed Exp p))
-> Exp (Complex (PatternTuple p))
-> Complex (Decomposed Exp p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (Exp (PatternTuple p) -> Decomposed Exp p,
 Exp (PatternTuple p) -> Decomposed Exp p)
-> (Exp (PatternTuple p), Exp (PatternTuple p))
-> (Decomposed Exp p, Decomposed Exp p)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
TupleHT.mapPair (p -> Exp (PatternTuple p) -> Decomposed Exp p
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose p
pr, p -> Exp (PatternTuple p) -> Decomposed Exp p
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
decompose p
pi) ((Exp (PatternTuple p), Exp (PatternTuple p))
 -> (Decomposed Exp p, Decomposed Exp p))
-> (Exp (Complex (PatternTuple p))
    -> (Exp (PatternTuple p), Exp (PatternTuple p)))
-> Exp (Complex (PatternTuple p))
-> (Decomposed Exp p, Decomposed Exp p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (Complex (PatternTuple p))
-> (Exp (PatternTuple p), Exp (PatternTuple p))
forall a. Exp (Complex a) -> (Exp a, Exp a)
deconsComplex

{- |
You can construct complex numbers this way,
but they will not make you happy,
because the numeric operations require a RealFloat instance
that we could only provide with lots of undefined methods
(also in its superclasses).
You may either define your own arithmetic
or use the NumericPrelude type classes.
-}
consComplex :: Exp a -> Exp a -> Exp (Complex a)
consComplex :: forall a. Exp a -> Exp a -> Exp (Complex a)
consComplex = (T a -> T a -> T (Complex a)) -> Exp a -> Exp a -> Exp (Complex a)
forall a b c. (T a -> T b -> T c) -> Exp a -> Exp b -> Exp c
forall (val :: * -> *) a b c.
Value val =>
(T a -> T b -> T c) -> val a -> val b -> val c
lift2 T a -> T a -> T (Complex a)
forall a. T a -> T a -> T (Complex a)
MultiValue.consComplex

deconsComplex :: Exp (Complex a) -> (Exp a, Exp a)
deconsComplex :: forall a. Exp (Complex a) -> (Exp a, Exp a)
deconsComplex Exp (Complex a)
c = ((T (Complex a) -> T a) -> Exp (Complex 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
lift1 T (Complex a) -> T a
forall a. T (Complex a) -> T a
MultiValue.realPart Exp (Complex a)
c, (T (Complex a) -> T a) -> Exp (Complex 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
lift1 T (Complex a) -> T a
forall a. T (Complex a) -> T a
MultiValue.imagPart Exp (Complex a)
c)


class (MultiValuesOf exp ~ mv, ExpressionsOf mv ~ exp) => Aggregate exp mv where
   type MultiValuesOf exp
   type ExpressionsOf mv
   bundle :: exp -> LLVM.CodeGenFunction r mv
   dissect :: mv -> exp

instance Aggregate (Exp a) (MultiValue.T a) where
   type MultiValuesOf (Exp a) = MultiValue.T a
   type ExpressionsOf (MultiValue.T a) = Exp a
   bundle :: forall r. Exp a -> CodeGenFunction r (T a)
bundle (Exp forall r. CodeGenFunction r (T a)
x) = CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
x
   dissect :: T a -> Exp a
dissect T a
x = (forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
Exp (T a -> CodeGenFunction r (T a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return T a
x)

instance (Aggregate ae al, Aggregate be bl) => Aggregate (ae,be) (al,bl) where
   type MultiValuesOf (ae,be) = (MultiValuesOf ae, MultiValuesOf be)
   type ExpressionsOf (al,bl) = (ExpressionsOf al, ExpressionsOf bl)
   bundle :: forall r. (ae, be) -> CodeGenFunction r (al, bl)
bundle (ae
a,be
b) = (al -> bl -> (al, bl))
-> CodeGenFunction r al
-> CodeGenFunction r bl
-> CodeGenFunction r (al, bl)
forall (m :: * -> *) a b r.
Monad m =>
(a -> b -> r) -> m a -> m b -> m r
Monad.lift2 (,) (ae -> CodeGenFunction r al
forall r. ae -> CodeGenFunction r al
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ae
a) (be -> CodeGenFunction r bl
forall r. be -> CodeGenFunction r bl
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle be
b)
   dissect :: (al, bl) -> (ae, be)
dissect (al
a,bl
b) = (al -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect al
a, bl -> be
forall exp mv. Aggregate exp mv => mv -> exp
dissect bl
b)

instance
   (Aggregate ae al, Aggregate be bl, Aggregate ce cl) =>
      Aggregate (ae,be,ce) (al,bl,cl) where
   type MultiValuesOf (ae,be,ce) =
            (MultiValuesOf ae, MultiValuesOf be, MultiValuesOf ce)
   type ExpressionsOf (al,bl,cl) =
            (ExpressionsOf al, ExpressionsOf bl, ExpressionsOf cl)
   bundle :: forall r. (ae, be, ce) -> CodeGenFunction r (al, bl, cl)
bundle (ae
a,be
b,ce
c) = (al -> bl -> cl -> (al, bl, cl))
-> CodeGenFunction r al
-> CodeGenFunction r bl
-> CodeGenFunction r cl
-> CodeGenFunction r (al, bl, cl)
forall (m :: * -> *) a b c r.
Monad m =>
(a -> b -> c -> r) -> m a -> m b -> m c -> m r
Monad.lift3 (,,) (ae -> CodeGenFunction r al
forall r. ae -> CodeGenFunction r al
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ae
a) (be -> CodeGenFunction r bl
forall r. be -> CodeGenFunction r bl
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle be
b) (ce -> CodeGenFunction r cl
forall r. ce -> CodeGenFunction r cl
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ce
c)
   dissect :: (al, bl, cl) -> (ae, be, ce)
dissect (al
a,bl
b,cl
c) = (al -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect al
a, bl -> be
forall exp mv. Aggregate exp mv => mv -> exp
dissect bl
b, cl -> ce
forall exp mv. Aggregate exp mv => mv -> exp
dissect cl
c)

instance
   (Aggregate ae al, Aggregate be bl, Aggregate ce cl, Aggregate de dl) =>
      Aggregate (ae,be,ce,de) (al,bl,cl,dl) where
   type MultiValuesOf (ae,be,ce,de) =
            (MultiValuesOf ae, MultiValuesOf be,
             MultiValuesOf ce, MultiValuesOf de)
   type ExpressionsOf (al,bl,cl,dl) =
            (ExpressionsOf al, ExpressionsOf bl,
             ExpressionsOf cl, ExpressionsOf dl)
   bundle :: forall r. (ae, be, ce, de) -> CodeGenFunction r (al, bl, cl, dl)
bundle (ae
a,be
b,ce
c,de
d) =
      (al -> bl -> cl -> dl -> (al, bl, cl, dl))
-> CodeGenFunction r al
-> CodeGenFunction r bl
-> CodeGenFunction r cl
-> CodeGenFunction r dl
-> CodeGenFunction r (al, bl, cl, dl)
forall (m :: * -> *) a b c d r.
Monad m =>
(a -> b -> c -> d -> r) -> m a -> m b -> m c -> m d -> m r
Monad.lift4 (,,,) (ae -> CodeGenFunction r al
forall r. ae -> CodeGenFunction r al
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ae
a) (be -> CodeGenFunction r bl
forall r. be -> CodeGenFunction r bl
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle be
b) (ce -> CodeGenFunction r cl
forall r. ce -> CodeGenFunction r cl
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle ce
c) (de -> CodeGenFunction r dl
forall r. de -> CodeGenFunction r dl
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle de
d)
   dissect :: (al, bl, cl, dl) -> (ae, be, ce, de)
dissect (al
a,bl
b,cl
c,dl
d) = (al -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect al
a, bl -> be
forall exp mv. Aggregate exp mv => mv -> exp
dissect bl
b, cl -> ce
forall exp mv. Aggregate exp mv => mv -> exp
dissect cl
c, dl -> de
forall exp mv. Aggregate exp mv => mv -> exp
dissect dl
d)

instance (Aggregate ae al) => Aggregate (Complex.T ae) (Complex.T al) where
   type MultiValuesOf (Complex.T ae) = Complex.T (MultiValuesOf ae)
   type ExpressionsOf (Complex.T al) = Complex.T (ExpressionsOf al)
   dissect :: T al -> T ae
dissect = (al -> ae) -> T al -> T ae
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap al -> ae
forall exp mv. Aggregate exp mv => mv -> exp
dissect
   bundle :: forall r. T ae -> CodeGenFunction r (T al)
bundle T ae
c =
      (al -> al -> T al)
-> CodeGenFunction r al
-> CodeGenFunction r al
-> CodeGenFunction r (T al)
forall (m :: * -> *) a b r.
Monad m =>
(a -> b -> r) -> m a -> m b -> m r
Monad.lift2 al -> al -> T al
forall a. a -> a -> T a
(Complex.+:)
         (ae -> CodeGenFunction r al
forall r. ae -> CodeGenFunction r al
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle (ae -> CodeGenFunction r al) -> ae -> CodeGenFunction r al
forall a b. (a -> b) -> a -> b
$ T ae -> ae
forall a. T a -> a
Complex.real T ae
c) (ae -> CodeGenFunction r al
forall r. ae -> CodeGenFunction r al
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle (ae -> CodeGenFunction r al) -> ae -> CodeGenFunction r al
forall a b. (a -> b) -> a -> b
$ T ae -> ae
forall a. T a -> a
Complex.imag T ae
c)


-- ToDo: move to numericprelude?
newtype Scalar a = Scalar a

instance (Aggregate exp mv) => Aggregate (Scalar exp) (Scalar.T mv) where
   type MultiValuesOf (Scalar exp) = Scalar.T (MultiValuesOf exp)
   type ExpressionsOf (Scalar.T mv)  = Scalar (ExpressionsOf mv)
   bundle :: forall r. Scalar exp -> CodeGenFunction r (T mv)
bundle (Scalar exp
x) = mv -> T mv
forall a. a -> T a
Scalar.Cons (mv -> T mv) -> CodeGenFunction r mv -> CodeGenFunction r (T mv)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> exp -> CodeGenFunction r mv
forall r. exp -> CodeGenFunction r mv
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
bundle exp
x
   dissect :: T mv -> Scalar exp
dissect (Scalar.Cons mv
x) = exp -> Scalar exp
forall a. a -> Scalar a
Scalar (exp -> Scalar exp) -> exp -> Scalar exp
forall a b. (a -> b) -> a -> b
$ mv -> exp
forall exp mv. Aggregate exp mv => mv -> exp
dissect mv
x

instance (Additive.C a) => Additive.C (Scalar a) where
   zero :: Scalar a
zero = a -> Scalar a
forall a. a -> Scalar a
Scalar a
forall a. C a => a
Additive.zero
   Scalar a
a + :: Scalar a -> Scalar a -> Scalar a
+ Scalar a
b = a -> Scalar a
forall a. a -> Scalar a
Scalar (a
a a -> a -> a
forall a. C a => a -> a -> a
Additive.+ a
b)
   Scalar a
a - :: Scalar a -> Scalar a -> Scalar a
- Scalar a
b = a -> Scalar a
forall a. a -> Scalar a
Scalar (a
a a -> a -> a
forall a. C a => a -> a -> a
Additive.- a
b)
   negate :: Scalar a -> Scalar a
negate (Scalar a
a) = a -> Scalar a
forall a. a -> Scalar a
Scalar (a -> Scalar a) -> a -> Scalar a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. C a => a -> a
Additive.negate a
a

instance (Ring.C a) => Ring.C (Scalar a) where
   Scalar a
a * :: Scalar a -> Scalar a -> Scalar a
* Scalar a
b = a -> Scalar a
forall a. a -> Scalar a
Scalar (a
a a -> a -> a
forall a. C a => a -> a -> a
Ring.* a
b)
   fromInteger :: Integer -> Scalar a
fromInteger = a -> Scalar a
forall a. a -> Scalar a
Scalar (a -> Scalar a) -> (Integer -> a) -> Integer -> Scalar a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. C a => Integer -> a
Ring.fromInteger

instance (Ring.C a, a~b) => Module.C (Scalar a) (Scalar b) where
   Scalar a
a *> :: Scalar a -> Scalar b -> Scalar b
*> Scalar b
b = b -> Scalar b
forall a. a -> Scalar a
Scalar (a
b
a b -> b -> b
forall a. C a => a -> a -> a
Ring.* b
b)


cons :: (MultiValue.C a) => a -> Exp a
cons :: forall a. C a => a -> Exp a
cons = T a -> Exp a
forall a. T a -> Exp a
forall (val :: * -> *) a. Value val => T a -> val a
lift0 (T a -> Exp a) -> (a -> T a) -> a -> Exp a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> T a
forall a. C a => a -> T a
MultiValue.cons

unit :: Exp ()
unit :: Exp ()
unit = () -> Exp ()
forall a. C a => a -> Exp a
cons ()

zero :: (MultiValue.C a) => Exp a
zero :: forall a. C a => Exp a
zero = T a -> Exp a
forall a. T a -> Exp a
forall (val :: * -> *) a. Value val => T a -> val a
lift0 T a
forall a. C a => T a
MultiValue.zero

add :: (MultiValue.Additive a) => Exp a -> Exp a -> Exp a
add :: forall a. Additive a => Exp a -> Exp a -> Exp a
add = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 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

sub :: (MultiValue.Additive a) => Exp a -> Exp a -> Exp a
sub :: forall a. Additive a => Exp a -> Exp a -> Exp a
sub = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 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

neg :: (MultiValue.Additive a) => Exp a -> Exp a
neg :: forall a. Additive a => Exp a -> Exp a
neg = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM 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

one :: (MultiValue.IntegerConstant a) => Exp a
one :: forall a. IntegerConstant a => Exp a
one = Integer -> Exp a
forall a. IntegerConstant a => Integer -> Exp a
fromInteger' Integer
1

mul :: (MultiValue.PseudoRing a) => Exp a -> Exp a -> Exp a
mul :: forall a. PseudoRing a => Exp a -> Exp a -> Exp a
mul = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. PseudoRing a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.mul

sqr :: (MultiValue.PseudoRing a) => Exp a -> Exp a
sqr :: forall a. PseudoRing a => Exp a -> Exp a
sqr = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a)
-> (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall a b. (a -> b) -> a -> b
$ \T a
x -> T a -> T a -> CodeGenFunction r (T a)
forall a r. PseudoRing a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.mul T a
x T a
x

recip :: (MultiValue.Field a, MultiValue.IntegerConstant a) => Exp a -> Exp a
recip :: forall a. (Field a, IntegerConstant a) => Exp a -> Exp a
recip = Exp a -> Exp a -> Exp a
forall a. Field a => Exp a -> Exp a -> Exp a
fdiv Exp a
forall a. IntegerConstant a => Exp a
one

fdiv :: (MultiValue.Field a) => Exp a -> Exp a -> Exp a
fdiv :: forall a. Field a => Exp a -> Exp a -> Exp a
fdiv = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Field a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.fdiv

sqrt :: (MultiValue.Algebraic a) => Exp a -> Exp a
sqrt :: forall a. Algebraic a => Exp a -> Exp a
sqrt = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Algebraic a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.sqrt

pow :: (MultiValue.Transcendental a) => Exp a -> Exp a -> Exp a
pow :: forall a. Transcendental a => Exp a -> Exp a -> Exp a
pow = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r.
Transcendental a =>
T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.pow

idiv :: (MultiValue.Integral a) => Exp a -> Exp a -> Exp a
idiv :: forall a. Integral a => Exp a -> Exp a -> Exp a
idiv = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Integral a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.idiv

irem :: (MultiValue.Integral a) => Exp a -> Exp a -> Exp a
irem :: forall a. Integral a => Exp a -> Exp a -> Exp a
irem = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Integral a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.irem

shl :: (MultiValue.BitShift a) => Exp a -> Exp a -> Exp a
shl :: forall a. BitShift a => Exp a -> Exp a -> Exp a
shl = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. BitShift a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.shl

shr :: (MultiValue.BitShift a) => Exp a -> Exp a -> Exp a
shr :: forall a. BitShift a => Exp a -> Exp a -> Exp a
shr = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. BitShift a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.shr

fromInteger' :: (MultiValue.IntegerConstant a) => Integer -> Exp a
fromInteger' :: forall a. IntegerConstant a => Integer -> Exp a
fromInteger' = T a -> Exp a
forall a. T a -> Exp a
forall (val :: * -> *) a. Value val => T a -> val a
lift0 (T a -> Exp a) -> (Integer -> T a) -> Integer -> Exp a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> T a
forall a. IntegerConstant a => Integer -> T a
MultiValue.fromInteger'

fromRational' :: (MultiValue.RationalConstant a) => Rational -> Exp a
fromRational' :: forall a. RationalConstant a => Rational -> Exp a
fromRational' = T a -> Exp a
forall a. T a -> Exp a
forall (val :: * -> *) a. Value val => T a -> val a
lift0 (T a -> Exp a) -> (Rational -> T a) -> Rational -> Exp a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> T a
forall a. RationalConstant a => Rational -> T a
MultiValue.fromRational'


boolPFrom8 :: Exp Bool8 -> Exp Bool
boolPFrom8 :: Exp Bool8 -> Exp Bool
boolPFrom8 = (T Bool8 -> T Bool) -> Exp Bool8 -> Exp Bool
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
lift1 T Bool8 -> T Bool
MultiValue.boolPFrom8

bool8FromP :: Exp Bool -> Exp Bool8
bool8FromP :: Exp Bool -> Exp Bool8
bool8FromP = (T Bool -> T Bool8) -> Exp Bool -> Exp Bool8
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
lift1 T Bool -> T Bool8
MultiValue.bool8FromP

intFromBool8 :: (MultiValue.NativeInteger i ir) => Exp Bool8 -> Exp i
intFromBool8 :: forall i ir. NativeInteger i ir => Exp Bool8 -> Exp i
intFromBool8 = (forall r. T Bool8 -> CodeGenFunction r (T i))
-> Exp Bool8 -> Exp i
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T Bool8 -> CodeGenFunction r (T i)
forall r. T Bool8 -> CodeGenFunction r (T i)
forall i ir r.
NativeInteger i ir =>
T Bool8 -> CodeGenFunction r (T i)
MultiValue.intFromBool8

floatFromBool8 :: (MultiValue.NativeFloating a ar) => Exp Bool8 -> Exp a
floatFromBool8 :: forall a ar. NativeFloating a ar => Exp Bool8 -> Exp a
floatFromBool8 = (forall r. T Bool8 -> CodeGenFunction r (T a))
-> Exp Bool8 -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T Bool8 -> CodeGenFunction r (T a)
forall r. T Bool8 -> CodeGenFunction r (T a)
forall a ar r.
NativeFloating a ar =>
T Bool8 -> CodeGenFunction r (T a)
MultiValue.floatFromBool8


toEnum ::
   (MultiValue.Repr w ~ LLVM.Value w) =>
   Exp w -> Exp (Enum.T w e)
toEnum :: forall w e. (Repr w ~ Value w) => Exp w -> Exp (T w e)
toEnum = (T w -> T (T w e)) -> Exp w -> Exp (T w e)
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
lift1 T w -> T (T w e)
forall w e. (Repr w ~ Value w) => T w -> T (T w e)
MultiValue.toEnum

fromEnum ::
   (MultiValue.Repr w ~ LLVM.Value w) =>
   Exp (Enum.T w e) -> Exp w
fromEnum :: forall w e. (Repr w ~ Value w) => Exp (T w e) -> Exp w
fromEnum = (T (T w e) -> T w) -> Exp (T w e) -> Exp w
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
lift1 T (T w e) -> T w
forall w e. (Repr w ~ Value w) => T (T w e) -> T w
MultiValue.fromEnum

succ, pred ::
   (LLVM.IsArithmetic w, SoV.IntegerConstant w) =>
   Exp (Enum.T w e) -> Exp (Enum.T w e)
succ :: forall w e.
(IsArithmetic w, IntegerConstant w) =>
Exp (T w e) -> Exp (T w e)
succ = (forall r. T (T w e) -> CodeGenFunction r (T (T w e)))
-> Exp (T w e) -> Exp (T w e)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T (T w e) -> CodeGenFunction r (T (T w e))
forall r. T (T w e) -> CodeGenFunction r (T (T w e))
forall w e r.
(IsArithmetic w, IntegerConstant w) =>
T (T w e) -> CodeGenFunction r (T (T w e))
MultiValue.succ
pred :: forall w e.
(IsArithmetic w, IntegerConstant w) =>
Exp (T w e) -> Exp (T w e)
pred = (forall r. T (T w e) -> CodeGenFunction r (T (T w e)))
-> Exp (T w e) -> Exp (T w e)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T (T w e) -> CodeGenFunction r (T (T w e))
forall r. T (T w e) -> CodeGenFunction r (T (T w e))
forall w e r.
(IsArithmetic w, IntegerConstant w) =>
T (T w e) -> CodeGenFunction r (T (T w e))
MultiValue.pred


fromFastMath :: Exp (FastMath.Number flags a) -> Exp a
fromFastMath :: forall flags a. Exp (Number flags a) -> Exp a
fromFastMath = (T (Number flags a) -> T a) -> Exp (Number flags 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
lift1 T (Number flags a) -> T a
forall flags a. T (Number flags a) -> T a
FastMath.mvDenumber

toFastMath :: Exp a -> Exp (FastMath.Number flags a)
toFastMath :: forall a flags. Exp a -> Exp (Number flags a)
toFastMath = (T a -> T (Number flags a)) -> Exp a -> Exp (Number flags 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
lift1 T a -> T (Number flags a)
forall a flags. T a -> T (Number flags a)
FastMath.mvNumber


minBound, maxBound :: (MultiValue.Bounded a) => Exp a
minBound :: forall a. Bounded a => Exp a
minBound = T a -> Exp a
forall a. T a -> Exp a
forall (val :: * -> *) a. Value val => T a -> val a
lift0 T a
forall a. Bounded a => T a
MultiValue.minBound
maxBound :: forall a. Bounded a => Exp a
maxBound = T a -> Exp a
forall a. T a -> Exp a
forall (val :: * -> *) a. Value val => T a -> val a
lift0 T a
forall a. Bounded a => T a
MultiValue.maxBound


cmp ::
   (MultiValue.Comparison a) =>
   LLVM.CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp :: forall a.
Comparison a =>
CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp CmpPredicate
ord = (forall r. T a -> T a -> CodeGenFunction r (T Bool))
-> Exp a -> Exp a -> Exp Bool
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 (CmpPredicate -> T a -> T a -> CodeGenFunction r (T Bool)
forall r. CmpPredicate -> T a -> T a -> CodeGenFunction r (T Bool)
forall a r.
Comparison a =>
CmpPredicate -> T a -> T a -> CodeGenFunction r (T Bool)
MultiValue.cmp CmpPredicate
ord)

infix 4 ==*, /=*, <*, <=*, >*, >=*

(==*), (/=*), (<*), (>=*), (>*), (<=*) ::
   (MultiValue.Comparison a) => Exp a -> Exp a -> Exp Bool
==* :: forall a. Comparison a => Exp a -> Exp a -> Exp Bool
(==*) = CmpPredicate -> Exp a -> Exp a -> Exp Bool
forall a.
Comparison a =>
CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp CmpPredicate
LLVM.CmpEQ
/=* :: forall a. Comparison a => Exp a -> Exp a -> Exp Bool
(/=*) = CmpPredicate -> Exp a -> Exp a -> Exp Bool
forall a.
Comparison a =>
CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp CmpPredicate
LLVM.CmpNE
<* :: forall a. Comparison a => Exp a -> Exp a -> Exp Bool
(<*)  = CmpPredicate -> Exp a -> Exp a -> Exp Bool
forall a.
Comparison a =>
CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp CmpPredicate
LLVM.CmpLT
>=* :: forall a. Comparison a => Exp a -> Exp a -> Exp Bool
(>=*) = CmpPredicate -> Exp a -> Exp a -> Exp Bool
forall a.
Comparison a =>
CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp CmpPredicate
LLVM.CmpGE
>* :: forall a. Comparison a => Exp a -> Exp a -> Exp Bool
(>*)  = CmpPredicate -> Exp a -> Exp a -> Exp Bool
forall a.
Comparison a =>
CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp CmpPredicate
LLVM.CmpGT
<=* :: forall a. Comparison a => Exp a -> Exp a -> Exp Bool
(<=*) = CmpPredicate -> Exp a -> Exp a -> Exp Bool
forall a.
Comparison a =>
CmpPredicate -> Exp a -> Exp a -> Exp Bool
cmp CmpPredicate
LLVM.CmpLE


min, max :: (MultiValue.Real a) => Exp a -> Exp a -> Exp a
min :: forall a. Real a => Exp a -> Exp a -> Exp a
min = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Real a => a -> a -> CodeGenFunction r a
forall r. T a -> T a -> CodeGenFunction r (T a)
A.min
max :: forall a. Real a => Exp a -> Exp a -> Exp a
max = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Real a => a -> a -> CodeGenFunction r a
forall r. T a -> T a -> CodeGenFunction r (T a)
A.max

limit :: (MultiValue.Real a) => (Exp a, Exp a) -> Exp a -> Exp a
limit :: forall a. Real a => (Exp a, Exp a) -> Exp a -> Exp a
limit (Exp a
l,Exp a
u) = Exp a -> Exp a -> Exp a
forall a. Real a => Exp a -> Exp a -> Exp a
max Exp a
l (Exp a -> Exp a) -> (Exp a -> Exp a) -> Exp a -> Exp a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp a -> Exp a -> Exp a
forall a. Real a => Exp a -> Exp a -> Exp a
min Exp a
u

fraction :: (MultiValue.Fraction a) => Exp a -> Exp a
fraction :: forall a. Fraction a => Exp a -> Exp a
fraction = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Fraction a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.fraction


true, false :: Exp Bool
true :: Exp Bool
true = Bool -> Exp Bool
forall a. C a => a -> Exp a
cons Bool
True
false :: Exp Bool
false = Bool -> Exp Bool
forall a. C a => a -> Exp a
cons Bool
False

infixr 3 &&*
(&&*) :: Exp Bool -> Exp Bool -> Exp Bool
&&* :: Exp Bool -> Exp Bool -> Exp Bool
(&&*) = (forall r. T Bool -> T Bool -> CodeGenFunction r (T Bool))
-> Exp Bool -> Exp Bool -> Exp Bool
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T Bool -> T Bool -> CodeGenFunction r (T Bool)
forall a r. Logic a => T a -> T a -> CodeGenFunction r (T a)
forall r. T Bool -> T Bool -> CodeGenFunction r (T Bool)
MultiValue.and

infixr 2 ||*
(||*) :: Exp Bool -> Exp Bool -> Exp Bool
||* :: Exp Bool -> Exp Bool -> Exp Bool
(||*) = (forall r. T Bool -> T Bool -> CodeGenFunction r (T Bool))
-> Exp Bool -> Exp Bool -> Exp Bool
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T Bool -> T Bool -> CodeGenFunction r (T Bool)
forall a r. Logic a => T a -> T a -> CodeGenFunction r (T a)
forall r. T Bool -> T Bool -> CodeGenFunction r (T Bool)
MultiValue.or

not :: Exp Bool -> Exp Bool
not :: Exp Bool -> Exp Bool
not = (forall r. T Bool -> CodeGenFunction r (T Bool))
-> Exp Bool -> Exp Bool
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T Bool -> CodeGenFunction r (T Bool)
forall a r. Logic a => T a -> CodeGenFunction r (T a)
forall r. T Bool -> CodeGenFunction r (T Bool)
MultiValue.inv

{- |
Like 'ifThenElse' but computes both alternative expressions
and then uses LLVM's efficient @select@ instruction.
-}
select :: (MultiValue.Select a) => Exp Bool -> Exp a -> Exp a -> Exp a
select :: forall a. Select a => Exp Bool -> Exp a -> Exp a -> Exp a
select = (forall r. T Bool -> T a -> T a -> CodeGenFunction r (T a))
-> Exp Bool -> Exp a -> Exp a -> Exp a
forall ae am be bm ce cm d.
(Aggregate ae am, Aggregate be bm, Aggregate ce cm) =>
(forall r. am -> bm -> cm -> CodeGenFunction r (T d))
-> ae -> be -> ce -> Exp d
liftM3 T Bool -> T a -> T a -> CodeGenFunction r (T a)
forall a r.
Select a =>
T Bool -> T a -> T a -> CodeGenFunction r (T a)
forall r. T Bool -> T a -> T a -> CodeGenFunction r (T a)
MultiValue.select

ifThenElse :: (MultiValue.C a) => Exp Bool -> Exp a -> Exp a -> Exp a
ifThenElse :: forall a. C a => Exp Bool -> Exp a -> Exp a -> Exp a
ifThenElse Exp Bool
ec Exp a
ex Exp a
ey =
   (forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique (do
      MultiValue.Cons Repr Bool
c <- Exp Bool -> forall r. CodeGenFunction r (T Bool)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
unExp Exp Bool
ec
      Value Bool
-> CodeGenFunction r (T a)
-> CodeGenFunction r (T a)
-> CodeGenFunction r (T a)
forall a r.
Phi a =>
Value Bool
-> CodeGenFunction r a
-> CodeGenFunction r a
-> CodeGenFunction r a
C.ifThenElse Repr Bool
Value Bool
c (Exp a -> forall r. CodeGenFunction r (T a)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
unExp Exp a
ex) (Exp a -> forall r. CodeGenFunction r (T a)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
unExp Exp a
ey))


complement :: (MultiValue.Logic a) => Exp a -> Exp a
complement :: forall a. Logic a => Exp a -> Exp a
complement = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Logic a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.inv

infixl 7 .&.*
(.&.*) :: (MultiValue.Logic a) => Exp a -> Exp a -> Exp a
.&.* :: forall a. Logic a => Exp a -> Exp a -> Exp a
(.&.*) = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Logic a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.and

infixl 5 .|.*
(.|.*) :: (MultiValue.Logic a) => Exp a -> Exp a -> Exp a
.|.* :: forall a. Logic a => Exp a -> Exp a -> Exp a
(.|.*) = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Logic a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.or

infixl 6 `xor`
xor :: (MultiValue.Logic a) => Exp a -> Exp a -> Exp a
xor :: forall a. Logic a => Exp a -> Exp a -> Exp a
xor = (forall r. T a -> T a -> CodeGenFunction r (T a))
-> Exp a -> Exp a -> Exp a
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T a -> CodeGenFunction r (T a)
forall a r. Logic a => T a -> T a -> CodeGenFunction r (T a)
forall r. T a -> T a -> CodeGenFunction r (T a)
MultiValue.xor


toMaybe :: Exp Bool -> Exp a -> Exp (Maybe a)
toMaybe :: forall a. Exp Bool -> Exp a -> Exp (Maybe a)
toMaybe = (T Bool -> T a -> T (Maybe a))
-> Exp Bool -> Exp a -> Exp (Maybe a)
forall a b c. (T a -> T b -> T c) -> Exp a -> Exp b -> Exp c
forall (val :: * -> *) a b c.
Value val =>
(T a -> T b -> T c) -> val a -> val b -> val c
lift2 T Bool -> T a -> T (Maybe a)
forall a. T Bool -> T a -> T (Maybe a)
MultiValue.toMaybe

maybe :: (MultiValue.C b) => Exp b -> (Exp a -> Exp b) -> Exp (Maybe a) -> Exp b
maybe :: forall b a.
C b =>
Exp b -> (Exp a -> Exp b) -> Exp (Maybe a) -> Exp b
maybe Exp b
n Exp a -> Exp b
j = (forall r. T (Maybe a) -> CodeGenFunction r (T b))
-> Exp (Maybe a) -> Exp b
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM ((forall r. T (Maybe a) -> CodeGenFunction r (T b))
 -> Exp (Maybe a) -> Exp b)
-> (forall r. T (Maybe a) -> CodeGenFunction r (T b))
-> Exp (Maybe a)
-> Exp b
forall a b. (a -> b) -> a -> b
$ \T (Maybe a)
m -> do
   let (MultiValue.Cons Repr Bool
b, T a
a) = T (Maybe a) -> (T Bool, T a)
forall a. T (Maybe a) -> (T Bool, T a)
MultiValue.splitMaybe T (Maybe a)
m
   Value Bool
-> CodeGenFunction r (T b)
-> CodeGenFunction r (T b)
-> CodeGenFunction r (T b)
forall a r.
Phi a =>
Value Bool
-> CodeGenFunction r a
-> CodeGenFunction r a
-> CodeGenFunction r a
C.ifThenElse Repr Bool
Value Bool
b ((Exp a -> Exp b) -> T a -> CodeGenFunction r (T b)
forall ae am be bm r.
(Aggregate ae am, Aggregate be bm) =>
(ae -> be) -> am -> CodeGenFunction r bm
unliftM1 Exp a -> Exp b
j T a
a) (Exp b -> forall r. CodeGenFunction r (T b)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
unExp Exp b
n)


instance
   (MultiValue.PseudoRing a, MultiValue.Real a, MultiValue.IntegerConstant a) =>
      Num (Exp a) where
   fromInteger :: Integer -> Exp a
fromInteger = Integer -> Exp a
forall a. IntegerConstant a => Integer -> Exp a
fromInteger'
   + :: Exp a -> Exp a -> Exp a
(+) = Exp a -> Exp a -> Exp a
forall a. Additive a => Exp a -> Exp a -> Exp a
add
   (-) = Exp a -> Exp a -> Exp a
forall a. Additive a => Exp a -> Exp a -> Exp a
sub
   negate :: Exp a -> Exp a
negate = Exp a -> Exp a
forall a. Additive a => Exp a -> Exp a
neg
   * :: Exp a -> Exp a -> Exp a
(*) = Exp a -> Exp a -> Exp a
forall a. PseudoRing a => Exp a -> Exp a -> Exp a
mul
   abs :: Exp a -> Exp a
abs = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Real a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.abs
   signum :: Exp a -> Exp a
signum = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Real a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.signum

instance
   (MultiValue.Field a, MultiValue.Real a, MultiValue.RationalConstant a) =>
      Fractional (Exp a) where
   fromRational :: Rational -> Exp a
fromRational = Rational -> Exp a
forall a. RationalConstant a => Rational -> Exp a
fromRational'
   / :: Exp a -> Exp a -> Exp a
(/) = Exp a -> Exp a -> Exp a
forall a. Field a => Exp a -> Exp a -> Exp a
fdiv

instance
   (MultiValue.Transcendental a, MultiValue.Real a,
    MultiValue.RationalConstant a) =>
      Floating (Exp a) where
   pi :: Exp a
pi = (forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
forall a r. Transcendental a => CodeGenFunction r (T a)
MultiValue.pi
   sin :: Exp a -> Exp a
sin = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.sin
   cos :: Exp a -> Exp a
cos = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.cos
   sqrt :: Exp a -> Exp a
sqrt = Exp a -> Exp a
forall a. Algebraic a => Exp a -> Exp a
sqrt
   ** :: Exp a -> Exp a -> Exp a
(**) = Exp a -> Exp a -> Exp a
forall a. Transcendental a => Exp a -> Exp a -> Exp a
pow
   exp :: Exp a -> Exp a
exp = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.exp
   log :: Exp a -> Exp a
log = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.log

   asin :: Exp a -> Exp a
asin Exp a
_ = [Char] -> Exp a
forall a. HasCallStack => [Char] -> a
error [Char]
"LLVM missing intrinsic: asin"
   acos :: Exp a -> Exp a
acos Exp a
_ = [Char] -> Exp a
forall a. HasCallStack => [Char] -> a
error [Char]
"LLVM missing intrinsic: acos"
   atan :: Exp a -> Exp a
atan Exp a
_ = [Char] -> Exp a
forall a. HasCallStack => [Char] -> a
error [Char]
"LLVM missing intrinsic: atan"

   sinh :: Exp a -> Exp a
sinh Exp a
x  = (Exp a -> Exp a
forall a. Floating a => a -> a
exp Exp a
x Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
- Exp a -> Exp a
forall a. Floating a => a -> a
exp (-Exp a
x)) Exp a -> Exp a -> Exp a
forall a. Fractional a => a -> a -> a
/ Exp a
2
   cosh :: Exp a -> Exp a
cosh Exp a
x  = (Exp a -> Exp a
forall a. Floating a => a -> a
exp Exp a
x Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
+ Exp a -> Exp a
forall a. Floating a => a -> a
exp (-Exp a
x)) Exp a -> Exp a -> Exp a
forall a. Fractional a => a -> a -> a
/ Exp a
2
   asinh :: Exp a -> Exp a
asinh Exp a
x = Exp a -> Exp a
forall a. Floating a => a -> a
log (Exp a
x Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
+ Exp a -> Exp a
forall a. Algebraic a => Exp a -> Exp a
sqrt (Exp a
xExp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
*Exp a
x Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
+ Exp a
1))
   acosh :: Exp a -> Exp a
acosh Exp a
x = Exp a -> Exp a
forall a. Floating a => a -> a
log (Exp a
x Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
+ Exp a -> Exp a
forall a. Algebraic a => Exp a -> Exp a
sqrt (Exp a
xExp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
*Exp a
x Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
- Exp a
1))
   atanh :: Exp a -> Exp a
atanh Exp a
x = (Exp a -> Exp a
forall a. Floating a => a -> a
log (Exp a
1 Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
+ Exp a
x) Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
- Exp a -> Exp a
forall a. Floating a => a -> a
log (Exp a
1 Exp a -> Exp a -> Exp a
forall a. Num a => a -> a -> a
- Exp a
x)) Exp a -> Exp a -> Exp a
forall a. Fractional a => a -> a -> a
/ Exp a
2


{- |
We do not require a numeric prelude superclass,
thus also LLVM only types like vectors are instances.
-}
instance (MultiValue.Additive a) => Additive.C (Exp a) where
   zero :: Exp a
zero = Exp a
forall a. C a => Exp a
zero
   + :: Exp a -> Exp a -> Exp a
(+) = Exp a -> Exp a -> Exp a
forall a. Additive a => Exp a -> Exp a -> Exp a
add
   (-) = Exp a -> Exp a -> Exp a
forall a. Additive a => Exp a -> Exp a -> Exp a
sub
   negate :: Exp a -> Exp a
negate = Exp a -> Exp a
forall a. Additive a => Exp a -> Exp a
neg

instance
   (MultiValue.PseudoRing a, MultiValue.IntegerConstant a) =>
      Ring.C (Exp a) where
   one :: Exp a
one = Exp a
forall a. IntegerConstant a => Exp a
one
   * :: Exp a -> Exp a -> Exp a
(*) = Exp a -> Exp a -> Exp a
forall a. PseudoRing a => Exp a -> Exp a -> Exp a
mul
   fromInteger :: Integer -> Exp a
fromInteger = Integer -> Exp a
forall a. IntegerConstant a => Integer -> Exp a
fromInteger'

{-
This instance is enough for Module here.
The difference to Module instances on Haskell tuples is,
that LLVM vectors cannot be nested.
-}
instance
   (a ~ MultiValue.Scalar v,
    MultiValue.PseudoModule v, MultiValue.IntegerConstant a) =>
      Module.C (Exp a) (Exp v) where
   *> :: Exp a -> Exp v -> Exp v
(*>) = (forall r. T a -> T v -> CodeGenFunction r (T v))
-> Exp a -> Exp v -> Exp v
forall ae am be bm c.
(Aggregate ae am, Aggregate be bm) =>
(forall r. am -> bm -> CodeGenFunction r (T c))
-> ae -> be -> Exp c
liftM2 T a -> T v -> CodeGenFunction r (T v)
T (Scalar v) -> T v -> CodeGenFunction r (T v)
forall v r.
PseudoModule v =>
T (Scalar v) -> T v -> CodeGenFunction r (T v)
forall r. T a -> T v -> CodeGenFunction r (T v)
forall r. T (Scalar v) -> T v -> CodeGenFunction r (T v)
MultiValue.scale

instance
   (MultiValue.Field a, MultiValue.RationalConstant a) =>
      Field.C (Exp a) where
   / :: Exp a -> Exp a -> Exp a
(/) = Exp a -> Exp a -> Exp a
forall a. Field a => Exp a -> Exp a -> Exp a
fdiv
   fromRational' :: Rational -> Exp a
fromRational' = Rational -> Exp a
forall a. RationalConstant a => Rational -> Exp a
fromRational' (Rational -> Exp a) -> (Rational -> Rational) -> Rational -> Exp a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Rational
forall a. C a => Rational -> a
Field.fromRational'

instance
   (MultiValue.Transcendental a, MultiValue.RationalConstant a) =>
      Algebraic.C (Exp a) where
   sqrt :: Exp a -> Exp a
sqrt = Exp a -> Exp a
forall a. Algebraic a => Exp a -> Exp a
sqrt
   root :: Integer -> Exp a -> Exp a
root Integer
n Exp a
x = Exp a -> Exp a -> Exp a
forall a. Transcendental a => Exp a -> Exp a -> Exp a
pow Exp a
x (Exp a -> Exp a
forall a. (Field a, IntegerConstant a) => Exp a -> Exp a
recip (Exp a -> Exp a) -> Exp a -> Exp a
forall a b. (a -> b) -> a -> b
$ Integer -> Exp a
forall a. IntegerConstant a => Integer -> Exp a
fromInteger' Integer
n)
   Exp a
x^/ :: Exp a -> Rational -> Exp a
^/Rational
r = Exp a -> Exp a -> Exp a
forall a. Transcendental a => Exp a -> Exp a -> Exp a
pow Exp a
x (Rational -> Exp a
forall a. C a => Rational -> a
Field.fromRational' Rational
r)


tau :: (MultiValue.Transcendental a, MultiValue.RationalConstant a) => Exp a
tau :: forall a. (Transcendental a, RationalConstant a) => Exp a
tau = Exp a -> Exp a -> Exp a
forall a. PseudoRing a => Exp a -> Exp a -> Exp a
mul (Integer -> Exp a
forall a. IntegerConstant a => Integer -> Exp a
fromInteger' Integer
2) Exp a
forall a. C a => a
Trans.pi

instance
   (MultiValue.Transcendental a, MultiValue.RationalConstant a) =>
      Trans.C (Exp a) where
   pi :: Exp a
pi = (forall r. CodeGenFunction r (T a)) -> Exp a
forall a. (forall r. CodeGenFunction r (T a)) -> Exp a
unique CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
forall a r. Transcendental a => CodeGenFunction r (T a)
MultiValue.pi
   sin :: Exp a -> Exp a
sin = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.sin
   cos :: Exp a -> Exp a
cos = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.cos
   ** :: Exp a -> Exp a -> Exp a
(**) = Exp a -> Exp a -> Exp a
forall a. Transcendental a => Exp a -> Exp a -> Exp a
pow
   exp :: Exp a -> Exp a
exp = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.exp
   log :: Exp a -> Exp a
log = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Transcendental a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.log

   asin :: Exp a -> Exp a
asin Exp a
_ = [Char] -> Exp a
forall a. HasCallStack => [Char] -> a
error [Char]
"LLVM missing intrinsic: asin"
   acos :: Exp a -> Exp a
acos Exp a
_ = [Char] -> Exp a
forall a. HasCallStack => [Char] -> a
error [Char]
"LLVM missing intrinsic: acos"
   atan :: Exp a -> Exp a
atan Exp a
_ = [Char] -> Exp a
forall a. HasCallStack => [Char] -> a
error [Char]
"LLVM missing intrinsic: atan"


instance
   (MultiValue.Real a, MultiValue.PseudoRing a, MultiValue.IntegerConstant a) =>
      Absolute.C (Exp a) where
   abs :: Exp a -> Exp a
abs = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Real a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.abs
   signum :: Exp a -> Exp a
signum = (forall r. T a -> CodeGenFunction r (T a)) -> Exp a -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T a)
forall a r. Real a => T a -> CodeGenFunction r (T a)
forall r. T a -> CodeGenFunction r (T a)
MultiValue.signum


fromIntegral ::
   (MultiValue.NativeInteger i ir, MultiValue.NativeFloating a ar) =>
   Exp i -> Exp a
fromIntegral :: forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
fromIntegral = (forall r. T i -> CodeGenFunction r (T a)) -> Exp i -> Exp a
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T i -> CodeGenFunction r (T a)
forall r. T i -> CodeGenFunction r (T a)
forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar) =>
T i -> CodeGenFunction r (T a)
MultiValue.fromIntegral

truncateToInt ::
   (MultiValue.NativeInteger i ir, MultiValue.NativeFloating a ar) =>
   Exp a -> Exp i
truncateToInt :: forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp a -> Exp i
truncateToInt = (forall r. T a -> CodeGenFunction r (T i)) -> Exp a -> Exp i
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T i)
forall r. T a -> CodeGenFunction r (T i)
forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar) =>
T a -> CodeGenFunction r (T i)
MultiValue.truncateToInt

floorToInt ::
   (MultiValue.NativeInteger i ir, MultiValue.NativeFloating a ar) =>
   Exp a -> Exp i
floorToInt :: forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp a -> Exp i
floorToInt = (forall r. T a -> CodeGenFunction r (T i)) -> Exp a -> Exp i
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T i)
forall r. T a -> CodeGenFunction r (T i)
forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar) =>
T a -> CodeGenFunction r (T i)
MultiValue.floorToInt

ceilingToInt ::
   (MultiValue.NativeInteger i ir, MultiValue.NativeFloating a ar) =>
   Exp a -> Exp i
ceilingToInt :: forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp a -> Exp i
ceilingToInt = (forall r. T a -> CodeGenFunction r (T i)) -> Exp a -> Exp i
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T i)
forall r. T a -> CodeGenFunction r (T i)
forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar) =>
T a -> CodeGenFunction r (T i)
MultiValue.ceilingToInt

roundToIntFast ::
   (MultiValue.NativeInteger i ir, MultiValue.NativeFloating a ar) =>
   Exp a -> Exp i
roundToIntFast :: forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp a -> Exp i
roundToIntFast = (forall r. T a -> CodeGenFunction r (T i)) -> Exp a -> Exp i
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T i)
forall r. T a -> CodeGenFunction r (T i)
forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar) =>
T a -> CodeGenFunction r (T i)
MultiValue.roundToIntFast

splitFractionToInt ::
   (MultiValue.NativeInteger i ir, MultiValue.NativeFloating a ar) =>
   Exp a -> (Exp i, Exp a)
splitFractionToInt :: forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp a -> (Exp i, Exp a)
splitFractionToInt = Exp (i, a) -> (Exp i, Exp a)
forall (val :: * -> *) a b.
Value val =>
val (a, b) -> (val a, val b)
unzip (Exp (i, a) -> (Exp i, Exp a))
-> (Exp a -> Exp (i, a)) -> Exp a -> (Exp i, Exp a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall r. T a -> CodeGenFunction r (T (i, a)))
-> Exp a -> Exp (i, a)
forall ae am b.
Aggregate ae am =>
(forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b
liftM T a -> CodeGenFunction r (T (i, a))
forall r. T a -> CodeGenFunction r (T (i, a))
forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar) =>
T a -> CodeGenFunction r (T (i, a))
MultiValue.splitFractionToInt