{-# 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 (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 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
(TypeNum.Positive n, Undefined (VectorValueOf n a)) =>
VectorValue n a where
type VectorValueOf n a
vectorValueOf :: Vector n a -> VectorValueOf n a
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 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
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