{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
module LLVM.Extra.Tuple (
   Phi(..), phiTraversable, addPhiFoldable,
   Undefined(..), undefPointed,
   Zero(..), zeroPointed,
   Value(..), valueOfFunctor,
   VectorValue(..),
   ) where

import LLVM.Extra.TuplePrivate (
   Phi(..), phiTraversable, addPhiFoldable,
   Undefined(..), undefPointed,
   Zero(..), zeroPointed,
   )
import qualified LLVM.Extra.EitherPrivate as Either
import qualified LLVM.Extra.MaybePrivate as Maybe
import qualified LLVM.Core as LLVM
import LLVM.Core (IsType, Vector)

import qualified Type.Data.Num.Decimal as TypeNum
import Type.Data.Num.Decimal ((:*:))

import qualified Control.Monad.Trans.State as MS
import qualified Control.Applicative as App
import qualified Control.Functor.HT as FuncHT

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

import qualified Foreign.Storable.Record.Tuple as StoreTuple
import Foreign.StablePtr (StablePtr, )
import Foreign.Ptr (FunPtr, Ptr, )

import qualified Data.EnumBitSet as EnumBitSet
import qualified Data.Enum.Storable as Enum
import qualified Data.Bool8 as Bool8
import Data.Complex (Complex((:+)))
import Data.Tagged (Tagged(unTagged))
import Data.Word (Word8, Word16, Word32, Word64, Word)
import Data.Int  (Int8,  Int16,  Int32,  Int64, )
import Data.Bool8 (Bool8)

import Prelude2010
import Prelude ()


-- * class for creating tuples of constant values

class (Undefined (ValueOf a)) => Value a where
   type ValueOf a
   valueOf :: a -> ValueOf a

instance (Value a, Value b) => Value (a,b) where
   type ValueOf (a,b) = (ValueOf a, ValueOf b)
   valueOf :: (a, b) -> ValueOf (a, b)
valueOf ~(a
a,b
b) = (a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf a
a, b -> ValueOf b
forall a. Value a => a -> ValueOf a
valueOf b
b)

instance (Value a, Value b, Value c) => Value (a,b,c) where
   type ValueOf (a,b,c) = (ValueOf a, ValueOf b, ValueOf c)
   valueOf :: (a, b, c) -> ValueOf (a, b, c)
valueOf ~(a
a,b
b,c
c) = (a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf a
a, b -> ValueOf b
forall a. Value a => a -> ValueOf a
valueOf b
b, c -> ValueOf c
forall a. Value a => a -> ValueOf a
valueOf c
c)

instance (Value a, Value b, Value c, Value d) => Value (a,b,c,d) where
   type ValueOf (a,b,c,d) = (ValueOf a, ValueOf b, ValueOf c, ValueOf d)
   valueOf :: (a, b, c, d) -> ValueOf (a, b, c, d)
valueOf ~(a
a,b
b,c
c,d
d) = (a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf a
a, b -> ValueOf b
forall a. Value a => a -> ValueOf a
valueOf b
b, c -> ValueOf c
forall a. Value a => a -> ValueOf a
valueOf c
c, d -> ValueOf d
forall a. Value a => a -> ValueOf a
valueOf d
d)

instance (Value tuple) => Value (StoreTuple.Tuple tuple) where
   type ValueOf (StoreTuple.Tuple tuple) = ValueOf tuple
   valueOf :: Tuple tuple -> ValueOf (Tuple tuple)
valueOf (StoreTuple.Tuple tuple
a) = tuple -> ValueOf tuple
forall a. Value a => a -> ValueOf a
valueOf tuple
a

instance (Value a) => Value (Maybe a) where
   type ValueOf (Maybe a) = Maybe.T (ValueOf a)
   valueOf :: Maybe a -> ValueOf (Maybe a)
valueOf = T (ValueOf a) -> (a -> T (ValueOf a)) -> Maybe a -> T (ValueOf a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ValueOf a -> T (ValueOf a)
forall a. a -> T a
Maybe.nothing ValueOf a
forall a. Undefined a => a
undef) (ValueOf a -> T (ValueOf a)
forall a. a -> T a
Maybe.just (ValueOf a -> T (ValueOf a))
-> (a -> ValueOf a) -> a -> T (ValueOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf)

instance (Value a, Value b) => Value (Either a b) where
   type ValueOf (Either a b) = Either.T (ValueOf a) (ValueOf b)
   valueOf :: Either a b -> ValueOf (Either a b)
valueOf =
      (a -> T (ValueOf a) (ValueOf b))
-> (b -> T (ValueOf a) (ValueOf b))
-> Either a b
-> T (ValueOf a) (ValueOf b)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
         (ValueOf b -> ValueOf a -> T (ValueOf a) (ValueOf b)
forall b a. b -> a -> T a b
Either.left ValueOf b
forall a. Undefined a => a
undef (ValueOf a -> T (ValueOf a) (ValueOf b))
-> (a -> ValueOf a) -> a -> T (ValueOf a) (ValueOf b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf)
         (ValueOf a -> ValueOf b -> T (ValueOf a) (ValueOf b)
forall a b. a -> b -> T a b
Either.right ValueOf a
forall a. Undefined a => a
undef (ValueOf b -> T (ValueOf a) (ValueOf b))
-> (b -> ValueOf b) -> b -> T (ValueOf a) (ValueOf b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> ValueOf b
forall a. Value a => a -> ValueOf a
valueOf)

instance Value Float  where type ValueOf Float  = LLVM.Value Float  ; valueOf :: Float -> ValueOf Float
valueOf = Float -> Value Float
Float -> ValueOf Float
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Double where type ValueOf Double = LLVM.Value Double ; valueOf :: Double -> ValueOf Double
valueOf = Double -> Value Double
Double -> ValueOf Double
forall a. IsConst a => a -> Value a
LLVM.valueOf
-- instance Value FP128  where type ValueOf FP128  = LLVM.Value FP128  ; valueOf = LLVM.valueOf
instance Value Bool   where type ValueOf Bool   = LLVM.Value Bool   ; valueOf :: Bool -> ValueOf Bool
valueOf = Bool -> Value Bool
Bool -> ValueOf Bool
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Bool8  where type ValueOf Bool8  = LLVM.Value Bool   ; valueOf :: Bool8 -> ValueOf Bool8
valueOf = Bool -> Value Bool
forall a. IsConst a => a -> Value a
LLVM.valueOf (Bool -> Value Bool) -> (Bool8 -> Bool) -> Bool8 -> Value Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool8 -> Bool
Bool8.toBool
instance Value Int    where type ValueOf Int    = LLVM.Value Int    ; valueOf :: Int -> ValueOf Int
valueOf = Int -> Value Int
Int -> ValueOf Int
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Int8   where type ValueOf Int8   = LLVM.Value Int8   ; valueOf :: Int8 -> ValueOf Int8
valueOf = Int8 -> Value Int8
Int8 -> ValueOf Int8
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Int16  where type ValueOf Int16  = LLVM.Value Int16  ; valueOf :: Int16 -> ValueOf Int16
valueOf = Int16 -> Value Int16
Int16 -> ValueOf Int16
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Int32  where type ValueOf Int32  = LLVM.Value Int32  ; valueOf :: Int32 -> ValueOf Int32
valueOf = Int32 -> Value Int32
Int32 -> ValueOf Int32
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Int64  where type ValueOf Int64  = LLVM.Value Int64  ; valueOf :: Int64 -> ValueOf Int64
valueOf = Int64 -> Value Int64
Int64 -> ValueOf Int64
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Word   where type ValueOf Word   = LLVM.Value Word   ; valueOf :: Word -> ValueOf Word
valueOf = Word -> Value Word
Word -> ValueOf Word
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Word8  where type ValueOf Word8  = LLVM.Value Word8  ; valueOf :: Word8 -> ValueOf Word8
valueOf = Word8 -> Value Word8
Word8 -> ValueOf Word8
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Word16 where type ValueOf Word16 = LLVM.Value Word16 ; valueOf :: Word16 -> ValueOf Word16
valueOf = Word16 -> Value Word16
Word16 -> ValueOf Word16
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Word32 where type ValueOf Word32 = LLVM.Value Word32 ; valueOf :: Word32 -> ValueOf Word32
valueOf = Word32 -> Value Word32
Word32 -> ValueOf Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value Word64 where type ValueOf Word64 = LLVM.Value Word64 ; valueOf :: Word64 -> ValueOf Word64
valueOf = Word64 -> Value Word64
Word64 -> ValueOf Word64
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance Value ()     where type ValueOf ()     = ()           ; valueOf :: () -> ValueOf ()
valueOf = () -> ()
() -> ValueOf ()
forall a. a -> a
id


instance (TypeNum.Positive n) => Value (LLVM.IntN n) where
   type ValueOf (LLVM.IntN n) = LLVM.Value (LLVM.IntN n)
   valueOf :: IntN n -> ValueOf (IntN n)
valueOf = IntN n -> Value (IntN n)
IntN n -> ValueOf (IntN n)
forall a. IsConst a => a -> Value a
LLVM.valueOf

instance (TypeNum.Positive n) => Value (LLVM.WordN n) where
   type ValueOf (LLVM.WordN n) = LLVM.Value (LLVM.WordN n)
   valueOf :: WordN n -> ValueOf (WordN n)
valueOf = WordN n -> Value (WordN n)
WordN n -> ValueOf (WordN n)
forall a. IsConst a => a -> Value a
LLVM.valueOf


instance Value (Ptr a) where
   type ValueOf (Ptr a) = LLVM.Value (Ptr a)
   valueOf :: Ptr a -> ValueOf (Ptr a)
valueOf = Ptr a -> Value (Ptr a)
Ptr a -> ValueOf (Ptr a)
forall a. IsConst a => a -> Value a
LLVM.valueOf

instance IsType a => Value (LLVM.Ptr a) where
   type ValueOf (LLVM.Ptr a) = LLVM.Value (LLVM.Ptr a)
   valueOf :: Ptr a -> ValueOf (Ptr a)
valueOf = Ptr a -> Value (Ptr a)
Ptr a -> ValueOf (Ptr a)
forall a. IsConst a => a -> Value a
LLVM.valueOf

instance LLVM.IsFunction a => Value (FunPtr a) where
   type ValueOf (FunPtr a) = LLVM.Value (FunPtr a)
   valueOf :: FunPtr a -> ValueOf (FunPtr a)
valueOf = FunPtr a -> Value (FunPtr a)
FunPtr a -> ValueOf (FunPtr a)
forall a. IsConst a => a -> Value a
LLVM.valueOf

instance Value (StablePtr a) where
   type ValueOf (StablePtr a) = LLVM.Value (StablePtr a)
   valueOf :: StablePtr a -> ValueOf (StablePtr a)
valueOf = StablePtr a -> Value (StablePtr a)
StablePtr a -> ValueOf (StablePtr a)
forall a. IsConst a => a -> Value a
LLVM.valueOf

instance
   (TypeNum.Positive n, VectorValue n a, Undefined (VectorValueOf n a)) =>
      Value (Vector n a) where
   type ValueOf (Vector n a) = VectorValueOf n a
   valueOf :: Vector n a -> ValueOf (Vector n a)
valueOf = Vector n a -> VectorValueOf n a
Vector n a -> ValueOf (Vector n a)
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
vectorValueOf


instance Value a => Value (Tagged tag a) where
   type ValueOf (Tagged tag a) = ValueOf a
   valueOf :: Tagged tag a -> ValueOf (Tagged tag a)
valueOf = a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf (a -> ValueOf a)
-> (Tagged tag a -> a) -> Tagged tag a -> ValueOf a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tagged tag a -> a
forall {k} (s :: k) b. Tagged s b -> b
unTagged

instance
   (LLVM.IsInteger w, LLVM.IsConst w, Num w, Enum e) =>
      Value (Enum.T w e) where
   type ValueOf (Enum.T w e) = LLVM.Value w
   valueOf :: T w e -> ValueOf (T w e)
valueOf = w -> Value w
forall a. IsConst a => a -> Value a
LLVM.valueOf (w -> Value w) -> (T w e -> w) -> T w e -> Value w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> w
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> w) -> (T w e -> Int) -> T w e -> w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Int
forall a. Enum a => a -> Int
fromEnum (e -> Int) -> (T w e -> e) -> T w e -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T w e -> e
forall w a. T w a -> a
Enum.toPlain

instance (LLVM.IsInteger w, LLVM.IsConst w) => Value (EnumBitSet.T w i) where
   type ValueOf (EnumBitSet.T w i) = LLVM.Value w
   valueOf :: T w i -> ValueOf (T w i)
valueOf = w -> Value w
forall a. IsConst a => a -> Value a
LLVM.valueOf (w -> Value w) -> (T w i -> w) -> T w i -> Value w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T w i -> w
forall word index. T word index -> word
EnumBitSet.decons

instance (Value a) => Value (Complex a) where
   type ValueOf (Complex a) = Complex (ValueOf a)
   valueOf :: Complex a -> ValueOf (Complex a)
valueOf (a
a:+a
b) = a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf a
a ValueOf a -> ValueOf a -> Complex (ValueOf a)
forall a. a -> a -> Complex a
:+ a -> ValueOf a
forall a. Value a => a -> ValueOf a
valueOf a
b


-- * class for vectors of tuples and other complex types

class
   (TypeNum.Positive n, Undefined (VectorValueOf n a)) =>
      VectorValue n a where
   type VectorValueOf n a
   vectorValueOf :: Vector n a -> VectorValueOf n a

-- may be simplified using a fake proof of TypeNum.Positive (n :*: m)
instance
   (TypeNum.Positive n, TypeNum.Positive m, TypeNum.Positive (n :*: m),
    Undefined (Vector (n :*: m) a)) =>
      VectorValue n (Vector m a) where
   type VectorValueOf n (Vector m a) = Vector (n :*: m) a
   vectorValueOf :: Vector n (Vector m a) -> VectorValueOf n (Vector m a)
vectorValueOf = [a] -> Vector (n :*: m) a
forall n a. Positive n => [a] -> Vector n a
vectorFromList ([a] -> Vector (n :*: m) a)
-> (Vector n (Vector m a) -> [a])
-> Vector n (Vector m a)
-> Vector (n :*: m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Vector m a -> [a]) -> Vector n (Vector m a) -> [a]
forall m a. Monoid m => (a -> m) -> Vector n a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
Fold.foldMap Vector m a -> [a]
forall a. Vector m a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList

vectorFromList :: (TypeNum.Positive n) => [a] -> Vector n a
vectorFromList :: forall n a. Positive n => [a] -> Vector n a
vectorFromList =
   State [a] (Vector n a) -> [a] -> Vector n a
forall s a. State s a -> s -> a
MS.evalState (State [a] (Vector n a) -> [a] -> Vector n a)
-> State [a] (Vector n a) -> [a] -> Vector n a
forall a b. (a -> b) -> a -> b
$ Vector n (StateT [a] Identity a) -> State [a] (Vector n a)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => Vector n (m a) -> m (Vector n a)
Trav.sequence (Vector n (StateT [a] Identity a) -> State [a] (Vector n a))
-> Vector n (StateT [a] Identity a) -> State [a] (Vector n a)
forall a b. (a -> b) -> a -> b
$ StateT [a] Identity a -> Vector n (StateT [a] Identity a)
forall a. a -> Vector n a
forall (f :: * -> *) a. Applicative f => a -> f a
App.pure (StateT [a] Identity a -> Vector n (StateT [a] Identity a))
-> StateT [a] Identity a -> Vector n (StateT [a] Identity a)
forall a b. (a -> b) -> a -> b
$ ([a] -> (a, [a])) -> StateT [a] Identity a
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
MS.state (([a] -> (a, [a])) -> StateT [a] Identity a)
-> ([a] -> (a, [a])) -> StateT [a] Identity a
forall a b. (a -> b) -> a -> b
$ \(a
y:[a]
ys) -> (a
y,[a]
ys)

instance (VectorValue n a, VectorValue n b) => VectorValue n (a,b) where
   type VectorValueOf n (a,b) = (VectorValueOf n a, VectorValueOf n b)
   vectorValueOf :: Vector n (a, b) -> VectorValueOf n (a, b)
vectorValueOf Vector n (a, b)
v =
      case Vector n (a, b) -> (Vector n a, Vector n b)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
FuncHT.unzip Vector n (a, b)
v of
         (Vector n a
a,Vector n b
b) -> (Vector n a -> VectorValueOf n a
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
vectorValueOf Vector n a
a, Vector n b -> VectorValueOf n b
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
vectorValueOf Vector n b
b)

instance
   (VectorValue n a, VectorValue n b, VectorValue n c) =>
      VectorValue n (a,b,c) where
   type VectorValueOf n (a,b,c) =
         (VectorValueOf n a, VectorValueOf n b, VectorValueOf n c)
   vectorValueOf :: Vector n (a, b, c) -> VectorValueOf n (a, b, c)
vectorValueOf Vector n (a, b, c)
v =
      case Vector n (a, b, c) -> (Vector n a, Vector n b, Vector n c)
forall (f :: * -> *) a b c.
Functor f =>
f (a, b, c) -> (f a, f b, f c)
FuncHT.unzip3 Vector n (a, b, c)
v of
         (Vector n a
a,Vector n b
b,Vector n c
c) -> (Vector n a -> VectorValueOf n a
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
vectorValueOf Vector n a
a, Vector n b -> VectorValueOf n b
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
vectorValueOf Vector n b
b, Vector n c -> VectorValueOf n c
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
vectorValueOf Vector n c
c)

instance (VectorValue n tuple) => VectorValue n (StoreTuple.Tuple tuple) where
   type VectorValueOf n (StoreTuple.Tuple tuple) = VectorValueOf n tuple
   vectorValueOf :: Vector n (Tuple tuple) -> VectorValueOf n (Tuple tuple)
vectorValueOf = Vector n tuple -> VectorValueOf n tuple
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
vectorValueOf (Vector n tuple -> VectorValueOf n tuple)
-> (Vector n (Tuple tuple) -> Vector n tuple)
-> Vector n (Tuple tuple)
-> VectorValueOf n tuple
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Tuple tuple -> tuple) -> Vector n (Tuple tuple) -> Vector n tuple
forall a b. (a -> b) -> Vector n a -> Vector n b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tuple tuple -> tuple
forall a. Tuple a -> a
StoreTuple.getTuple

instance (TypeNum.Positive n) => VectorValue n Float where
   type VectorValueOf n Float  = LLVM.Value (Vector n Float)
   vectorValueOf :: Vector n Float -> VectorValueOf n Float
vectorValueOf = Vector n Float -> Value (Vector n Float)
Vector n Float -> VectorValueOf n Float
forall a. IsConst a => a -> Value a
LLVM.valueOf

instance (TypeNum.Positive n) => VectorValue n Double where
   type VectorValueOf n Double = LLVM.Value (Vector n Double)
   vectorValueOf :: Vector n Double -> VectorValueOf n Double
vectorValueOf = Vector n Double -> Value (Vector n Double)
Vector n Double -> VectorValueOf n Double
forall a. IsConst a => a -> Value a
LLVM.valueOf
{-
instance (TypeNum.Positive n) => VectorValue n FP128  where
   type VectorValueOf n FP128  = LLVM.Value (Vector n FP128)
   vectorValueOf = LLVM.valueOf
-}
instance (TypeNum.Positive n) => VectorValue n Bool   where
   type VectorValueOf n Bool   = LLVM.Value (Vector n Bool)
   vectorValueOf :: Vector n Bool -> VectorValueOf n Bool
vectorValueOf = Vector n Bool -> Value (Vector n Bool)
Vector n Bool -> VectorValueOf n Bool
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Bool8  where
   type VectorValueOf n Bool8  = LLVM.Value (Vector n Bool)
   vectorValueOf :: Vector n Bool8 -> VectorValueOf n Bool8
vectorValueOf = Vector n Bool -> Value (Vector n Bool)
forall a. IsConst a => a -> Value a
LLVM.valueOf (Vector n Bool -> Value (Vector n Bool))
-> (Vector n Bool8 -> Vector n Bool)
-> Vector n Bool8
-> Value (Vector n Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool8 -> Bool) -> Vector n Bool8 -> Vector n Bool
forall a b. (a -> b) -> Vector n a -> Vector n b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool8 -> Bool
Bool8.toBool
instance (TypeNum.Positive n) => VectorValue n Int  where
   type VectorValueOf n Int    = LLVM.Value (Vector n Int)
   vectorValueOf :: Vector n Int -> VectorValueOf n Int
vectorValueOf = Vector n Int -> Value (Vector n Int)
Vector n Int -> VectorValueOf n Int
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Int8   where
   type VectorValueOf n Int8   = LLVM.Value (Vector n Int8)
   vectorValueOf :: Vector n Int8 -> VectorValueOf n Int8
vectorValueOf = Vector n Int8 -> Value (Vector n Int8)
Vector n Int8 -> VectorValueOf n Int8
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Int16  where
   type VectorValueOf n Int16  = LLVM.Value (Vector n Int16)
   vectorValueOf :: Vector n Int16 -> VectorValueOf n Int16
vectorValueOf = Vector n Int16 -> Value (Vector n Int16)
Vector n Int16 -> VectorValueOf n Int16
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Int32  where
   type VectorValueOf n Int32  = LLVM.Value (Vector n Int32)
   vectorValueOf :: Vector n Int32 -> VectorValueOf n Int32
vectorValueOf = Vector n Int32 -> Value (Vector n Int32)
Vector n Int32 -> VectorValueOf n Int32
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Int64  where
   type VectorValueOf n Int64  = LLVM.Value (Vector n Int64)
   vectorValueOf :: Vector n Int64 -> VectorValueOf n Int64
vectorValueOf = Vector n Int64 -> Value (Vector n Int64)
Vector n Int64 -> VectorValueOf n Int64
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Word   where
   type VectorValueOf n Word   = LLVM.Value (Vector n Word)
   vectorValueOf :: Vector n Word -> VectorValueOf n Word
vectorValueOf = Vector n Word -> Value (Vector n Word)
Vector n Word -> VectorValueOf n Word
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Word8  where
   type VectorValueOf n Word8  = LLVM.Value (Vector n Word8)
   vectorValueOf :: Vector n Word8 -> VectorValueOf n Word8
vectorValueOf = Vector n Word8 -> Value (Vector n Word8)
Vector n Word8 -> VectorValueOf n Word8
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Word16 where
   type VectorValueOf n Word16 = LLVM.Value (Vector n Word16)
   vectorValueOf :: Vector n Word16 -> VectorValueOf n Word16
vectorValueOf = Vector n Word16 -> Value (Vector n Word16)
Vector n Word16 -> VectorValueOf n Word16
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Word32 where
   type VectorValueOf n Word32 = LLVM.Value (Vector n Word32)
   vectorValueOf :: Vector n Word32 -> VectorValueOf n Word32
vectorValueOf = Vector n Word32 -> Value (Vector n Word32)
Vector n Word32 -> VectorValueOf n Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf
instance (TypeNum.Positive n) => VectorValue n Word64 where
   type VectorValueOf n Word64 = LLVM.Value (Vector n Word64)
   vectorValueOf :: Vector n Word64 -> VectorValueOf n Word64
vectorValueOf = Vector n Word64 -> Value (Vector n Word64)
Vector n Word64 -> VectorValueOf n Word64
forall a. IsConst a => a -> Value a
LLVM.valueOf


-- * default methods for LLVM classes

valueOfFunctor :: (Value h, Functor f) => f h -> f (ValueOf h)
valueOfFunctor :: forall h (f :: * -> *).
(Value h, Functor f) =>
f h -> f (ValueOf h)
valueOfFunctor = (h -> ValueOf h) -> f h -> f (ValueOf h)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap h -> ValueOf h
forall a. Value a => a -> ValueOf a
valueOf