LLVM.Extra.Multi.Value

Documentation

newtype T a

Constructors

Cons (ValueOf a)

Instances

C T

C a => Zero (T a)

C a => Undefined (T a)

C a => Phi (T a)

Select a => Select (T a)

Transcendental a => Transcendental (T a)

Algebraic a => Algebraic (T a)

Logic a => Logic (T a)

FloatingComparison a => FloatingComparison (T a)

Comparison a => Comparison (T a)

Fraction a => Fraction (T a)

Real a => Real (T a)

RationalConstant a => RationalConstant (T a)

Field a => Field (T a)

IntegerConstant a => IntegerConstant (T a)

PseudoModule a => PseudoModule (T a)

PseudoRing a => PseudoRing (T a)

Additive a => Additive (T a)

Compose (T a)

(C a, C (ValueOf a)) => C (T a)

class C a where

Methods

cons :: a -> T a

undef :: T a

zero :: T a

phi :: BasicBlock -> T a -> CodeGenFunction r (T a)

addPhi :: BasicBlock -> T a -> T a -> CodeGenFunction r ()

Instances

C Bool

C Double

C Float

C Int

C Int8

C Int16

C Int32

C Int64

C Word

C Word8

C Word16

C Word32

C Word64

C ()

C Bool8

C (StablePtr a)

C (Ptr a)

IsFunction a => C (FunPtr a)

C a => C (Complex a)

C a => C (Maybe a)

Positive n => C (IntN n)

IsType a => C (Ptr a)

Positive n => C (WordN n)

C tuple => C (Tuple tuple)

(C a, C b) => C (a, b)

(IsInteger w, IsConst w) => C (T w i)

(Positive n, C a) => C (Vector n a)

(IsInteger w, IsConst w, Num w, Enum e) => C (T w e)

C a => C (Tagged tag a)

MultiValue a => C (Number flags a)

(C a, C b, C c) => C (a, b, c)

(C a, C b, C c, C d) => C (a, b, c, d)

consPrimitive :: (IsConst al, Value al ~ ValueOf a) => al -> T a

undefPrimitive :: (IsType al, Value al ~ ValueOf a) => T a

zeroPrimitive :: (IsType al, Value al ~ ValueOf a) => T a

phiPrimitive :: (IsFirstClass al, Value al ~ ValueOf a) => BasicBlock -> T a -> CodeGenFunction r (T a)

addPhiPrimitive :: (IsFirstClass al, Value al ~ ValueOf a) => BasicBlock -> T a -> T a -> CodeGenFunction r ()

consTuple :: Value a => a -> T a

undefTuple :: (Value a, ValueOf a ~ al, Undefined al) => T a

zeroTuple :: (Value a, ValueOf a ~ al, Zero al) => T a

phiTuple :: (Value a, ValueOf a ~ al, Phi al) => BasicBlock -> T a -> CodeGenFunction r (T a)

addPhiTuple :: (Value a, ValueOf a ~ al, Phi al) => BasicBlock -> T a -> T a -> CodeGenFunction r ()

consUnit :: ValueOf a ~ () => a -> T a

undefUnit :: ValueOf a ~ () => T a

zeroUnit :: ValueOf a ~ () => T a

phiUnit :: ValueOf a ~ () => BasicBlock -> T a -> CodeGenFunction r (T a)

addPhiUnit :: ValueOf a ~ () => BasicBlock -> T a -> T a -> CodeGenFunction r ()

boolPFrom8 :: T Bool8 -> T Bool

bool8FromP :: T Bool -> T Bool8

intFromBool8 :: NativeInteger i ir => T Bool8 -> CodeGenFunction r (T i)

floatFromBool8 :: NativeFloating a ar => T Bool8 -> CodeGenFunction r (T a)

toEnum :: ValueOf w ~ Value w => T w -> T (T w e)

fromEnum :: ValueOf w ~ Value w => T (T w e) -> T w

succ :: (IsArithmetic w, IntegerConstant w) => T (T w e) -> CodeGenFunction r (T (T w e))

pred :: (IsArithmetic w, IntegerConstant w) => T (T w e) -> CodeGenFunction r (T (T w e))

cmpEnum :: (CmpRet w, IsPrimitive w) => CmpPredicate -> T (T w a) -> T (T w a) -> CodeGenFunction r (T Bool)

class C a => Bounded a where

Methods

minBound, maxBound :: T a

Instances

(IsInteger w, IsConst w, Num w, Enum e, Bounded e) => Bounded (T w e)

splitMaybe :: T (Maybe a) -> (T Bool, T a)

toMaybe :: T Bool -> T a -> T (Maybe a)

nothing :: C a => T (Maybe a)

just :: T a -> T (Maybe a)

fst :: T (a, b) -> T a

snd :: T (a, b) -> T b

curry :: (T (a, b) -> c) -> T a -> T b -> c

uncurry :: (T a -> T b -> c) -> T (a, b) -> c

mapFst :: (T a0 -> T a1) -> T (a0, b) -> T (a1, b)

mapSnd :: (T b0 -> T b1) -> T (a, b0) -> T (a, b1)

mapFstF :: Functor f => (T a0 -> f (T a1)) -> T (a0, b) -> f (T (a1, b))

mapSndF :: Functor f => (T b0 -> f (T b1)) -> T (a, b0) -> f (T (a, b1))

swap :: T (a, b) -> T (b, a)

fst3 :: T (a, b, c) -> T a

snd3 :: T (a, b, c) -> T b

thd3 :: T (a, b, c) -> T c

mapFst3 :: (T a0 -> T a1) -> T (a0, b, c) -> T (a1, b, c)

mapSnd3 :: (T b0 -> T b1) -> T (a, b0, c) -> T (a, b1, c)

mapThd3 :: (T c0 -> T c1) -> T (a, b, c0) -> T (a, b, c1)

mapFst3F :: Functor f => (T a0 -> f (T a1)) -> T (a0, b, c) -> f (T (a1, b, c))

mapSnd3F :: Functor f => (T b0 -> f (T b1)) -> T (a, b0, c) -> f (T (a, b1, c))

mapThd3F :: Functor f => (T c0 -> f (T c1)) -> T (a, b, c0) -> f (T (a, b, c1))

zip :: T a -> T b -> T (a, b)

zip3 :: T a -> T b -> T c -> T (a, b, c)

zip4 :: T a -> T b -> T c -> T d -> T (a, b, c, d)

unzip :: T (a, b) -> (T a, T b)

unzip3 :: T (a, b, c) -> (T a, T b, T c)

unzip4 :: T (a, b, c, d) -> (T a, T b, T c, T d)

tuple :: T tuple -> T (Tuple tuple)

untuple :: T (Tuple tuple) -> T tuple

tag :: T a -> T (Tagged tag a)

untag :: T (Tagged tag a) -> T a

liftTaggedM :: Monad m => (T a -> m (T b)) -> T (Tagged tag a) -> m (T (Tagged tag b))

liftTaggedM2 :: Monad m => (T a -> T b -> m (T c)) -> T (Tagged tag a) -> T (Tagged tag b) -> m (T (Tagged tag c))

consComplex :: T a -> T a -> T (Complex a)

deconsComplex :: T (Complex a) -> (T a, T a)

class Compose multituple where

Associated Types

type Composed multituple

Methods

compose :: multituple -> T (Composed multituple)

A nested zip.

Instances

Compose ()

Compose a => Compose (Complex a)

Compose tuple => Compose (Tuple tuple)

Compose (T a)

(Compose a, Compose b) => Compose (a, b)

Compose a => Compose (Tagged tag a)

(Flags flags, Compose a) => Compose (Number flags a)

(Compose a, Compose b, Compose c) => Compose (a, b, c)

(Compose a, Compose b, Compose c, Compose d) => Compose (a, b, c, d)

class Composed (Decomposed T pattern) ~ PatternTuple pattern => Decompose pattern where

Methods

decompose :: pattern -> T (PatternTuple pattern) -> Decomposed T pattern

A nested unzip. Since it is not obvious how deep to decompose nested tuples, you must provide a pattern of the decomposed tuple. E.g.

 f :: MultiValue ((a,b),(c,d)) ->
      ((MultiValue a, MultiValue b), MultiValue (c,d))
 f = decompose ((atom,atom),atom)

Instances

Decompose ()

Decompose pa => Decompose (Complex pa)

Decompose p => Decompose (Tuple p)

Decompose (Atom a)

(Decompose pa, Decompose pb) => Decompose (pa, pb)

Decompose pa => Decompose (Tagged tag pa)

(Flags flags, Decompose pa) => Decompose (Number flags pa)

(Decompose pa, Decompose pb, Decompose pc) => Decompose (pa, pb, pc)

(Decompose pa, Decompose pb, Decompose pc, Decompose pd) => Decompose (pa, pb, pc, pd)

type family Decomposed f pattern

type family PatternTuple pattern

modify :: (Compose a, Decompose pattern) => pattern -> (Decomposed T pattern -> a) -> T (PatternTuple pattern) -> T (Composed a)

A combination of compose and decompose that let you operate on tuple multivalues as Haskell tuples.

modify2 :: (Compose a, Decompose patternA, Decompose patternB) => patternA -> patternB -> (Decomposed T patternA -> Decomposed T patternB -> a) -> T (PatternTuple patternA) -> T (PatternTuple patternB) -> T (Composed a)

modifyF :: (Compose a, Decompose pattern, Functor f) => pattern -> (Decomposed T pattern -> f a) -> T (PatternTuple pattern) -> f (T (Composed a))

modifyF2 :: (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))

data Atom a

Constructors

Atom

Instances

Decompose (Atom a)

atom :: Atom a

realPart :: T (Complex a) -> T a

imagPart :: T (Complex a) -> T a

lift1 :: (ValueOf a -> ValueOf b) -> T a -> T b

liftM0 :: Monad m => m (ValueOf a) -> m (T a)

liftM :: Monad m => (ValueOf a -> m (ValueOf b)) -> T a -> m (T b)

liftM2 :: Monad m => (ValueOf a -> ValueOf b -> m (ValueOf c)) -> T a -> T b -> m (T c)

liftM3 :: Monad m => (ValueOf a -> ValueOf b -> ValueOf c -> m (ValueOf d)) -> T a -> T b -> T c -> m (T d)

class C a => IntegerConstant a where

Methods

fromInteger' :: Integer -> T a

Instances

IntegerConstant Double

IntegerConstant Float

IntegerConstant Int

IntegerConstant Int8

IntegerConstant Int16

IntegerConstant Int32

IntegerConstant Int64

IntegerConstant Word

IntegerConstant Word8

IntegerConstant Word16

IntegerConstant Word32

IntegerConstant Word64

Positive n => IntegerConstant (IntN n)

Positive n => IntegerConstant (WordN n)

(Positive n, IntegerConstant a) => IntegerConstant (Vector n a)

IntegerConstant a => IntegerConstant (Tagged tag a)

(Flags flags, MultiValue a, IntegerConstant a) => IntegerConstant (Number flags a)

class IntegerConstant a => RationalConstant a where

Methods

fromRational' :: Rational -> T a

Instances

RationalConstant Double

RationalConstant Float

(Positive n, RationalConstant a) => RationalConstant (Vector n a)

RationalConstant a => RationalConstant (Tagged tag a)

(Flags flags, MultiValue a, RationalConstant a) => RationalConstant (Number flags a)

class C a => Additive a where

Methods

add :: T a -> T a -> CodeGenFunction r (T a)

sub :: T a -> T a -> CodeGenFunction r (T a)

neg :: T a -> CodeGenFunction r (T a)

Instances

Additive Double

Additive Float

Additive Int

Additive Int8

Additive Int16

Additive Int32

Additive Int64

Additive Word

Additive Word8

Additive Word16

Additive Word32

Additive Word64

Positive n => Additive (IntN n)

Positive n => Additive (WordN n)

(Positive n, Additive a) => Additive (Vector n a)

Additive a => Additive (Tagged tag a)

(Flags flags, MultiValue a, Additive a) => Additive (Number flags a)

inc :: (Additive i, IntegerConstant i) => T i -> CodeGenFunction r (T i)

dec :: (Additive i, IntegerConstant i) => T i -> CodeGenFunction r (T i)

class Additive a => PseudoRing a where

Methods

mul :: T a -> T a -> CodeGenFunction r (T a)

Instances

PseudoRing Double

PseudoRing Float

PseudoRing Int

PseudoRing Int8

PseudoRing Int16

PseudoRing Int32

PseudoRing Int64

PseudoRing Word

PseudoRing Word8

PseudoRing Word16

PseudoRing Word32

PseudoRing Word64

PseudoRing a => PseudoRing (Tagged tag a)

(Flags flags, MultiValue a, PseudoRing a) => PseudoRing (Number flags a)

class PseudoRing a => Field a where

Methods

fdiv :: T a -> T a -> CodeGenFunction r (T a)

Instances

Field Double

Field Float

Field a => Field (Tagged tag a)

(Flags flags, MultiValue a, Field a) => Field (Number flags a)

type family Scalar vector :: *

class (PseudoRing (Scalar v), Additive v) => PseudoModule v where

Methods

scale :: T (Scalar v) -> T v -> CodeGenFunction r (T v)

Instances

PseudoModule Double

PseudoModule Float

PseudoModule a => PseudoModule (Tagged tag a)

(Flags flags, MultiValue a, ~ * a (Scalar v), MultiValue v, PseudoModule v) => PseudoModule (Number flags v)

class Additive a => Real a where

Methods

min :: T a -> T a -> CodeGenFunction r (T a)

max :: T a -> T a -> CodeGenFunction r (T a)

abs :: T a -> CodeGenFunction r (T a)

signum :: T a -> CodeGenFunction r (T a)

Instances

Real Double

Real Float

Real Int

Real Int8

Real Int16

Real Int32

Real Int64

Real Word

Real Word8

Real Word16

Real Word32

Real Word64

Positive n => Real (IntN n)

Positive n => Real (WordN n)

Real a => Real (Tagged tag a)

(Flags flags, MultiValue a, Real a) => Real (Number flags a)

class Real a => Fraction a where

Methods

truncate :: T a -> CodeGenFunction r (T a)

fraction :: T a -> CodeGenFunction r (T a)

Instances

Fraction Double

Fraction Float

Fraction a => Fraction (Tagged tag a)

(Flags flags, MultiValue a, Fraction a) => Fraction (Number flags a)

class (ValueOf i ~ Value ir, IsInteger ir, IntegerConstant ir, CmpRet ir, IsPrimitive ir) => NativeInteger i ir

Instances

NativeInteger Int Int

NativeInteger Int8 Int8

NativeInteger Int16 Int16

NativeInteger Int32 Int32

NativeInteger Int64 Int64

NativeInteger Word Word

NativeInteger Word8 Word8

NativeInteger Word16 Word16

NativeInteger Word32 Word32

NativeInteger Word64 Word64

NativeInteger a a => NativeInteger (Tagged tag a) a

class (ValueOf a ~ Value ar, IsFloating ar, RationalConstant ar, CmpRet ar, IsPrimitive ar) => NativeFloating a ar

Instances

NativeFloating Double Double

NativeFloating Float Float

truncateToInt :: (NativeInteger i ir, NativeFloating a ar) => T a -> CodeGenFunction r (T i)

roundToIntFast :: (NativeInteger i ir, NativeFloating a ar) => T a -> CodeGenFunction r (T i)

ceilingToInt :: (NativeInteger i ir, NativeFloating a ar) => T a -> CodeGenFunction r (T i)

floorToInt :: (NativeInteger i ir, NativeFloating a ar) => T a -> CodeGenFunction r (T i)

splitFractionToInt :: (NativeInteger i ir, NativeFloating a ar) => T a -> CodeGenFunction r (T (i, a))

class Field a => Algebraic a where

Methods

sqrt :: T a -> CodeGenFunction r (T a)

Instances

Algebraic Double

Algebraic Float

Algebraic a => Algebraic (Tagged tag a)

(Flags flags, MultiValue a, Algebraic a) => Algebraic (Number flags a)

class Algebraic a => Transcendental a where

Methods

pi :: CodeGenFunction r (T a)

sin, log, exp, cos :: T a -> CodeGenFunction r (T a)

pow :: T a -> T a -> CodeGenFunction r (T a)

Instances

Transcendental Double

Transcendental Float

Transcendental a => Transcendental (Tagged tag a)

(Flags flags, MultiValue a, Transcendental a) => Transcendental (Number flags a)

class C a => Select a where

Methods

select :: T Bool -> T a -> T a -> CodeGenFunction r (T a)

Instances

Select Bool

Select Double

Select Float

Select Int

Select Int8

Select Int16

Select Int32

Select Int64

Select Word

Select Word8

Select Word16

Select Word32

Select Word64

Select Bool8

(Select a, Select b) => Select (a, b)

Select a => Select (Tagged tag a)

(Flags flags, MultiValue a, Select a) => Select (Number flags a)

(Select a, Select b, Select c) => Select (a, b, c)

class Real a => Comparison a where

Methods

cmp :: CmpPredicate -> T a -> T a -> CodeGenFunction r (T Bool)

It must hold

 max x y  ==  do gt <- cmp CmpGT x y; select gt x y

Instances

Comparison Double

Comparison Float

Comparison Int

Comparison Int8

Comparison Int16

Comparison Int32

Comparison Int64

Comparison Word

Comparison Word8

Comparison Word16

Comparison Word32

Comparison Word64

Positive n => Comparison (IntN n)

Positive n => Comparison (WordN n)

Comparison a => Comparison (Tagged tag a)

(Flags flags, MultiValue a, Comparison a) => Comparison (Number flags a)

class Comparison a => FloatingComparison a where

Methods

fcmp :: FPPredicate -> T a -> T a -> CodeGenFunction r (T Bool)

Instances

FloatingComparison Float

FloatingComparison a => FloatingComparison (Tagged tag a)

(Flags flags, MultiValue a, FloatingComparison a) => FloatingComparison (Number flags a)

class C a => Logic a where

Methods

and :: T a -> T a -> CodeGenFunction r (T a)

or :: T a -> T a -> CodeGenFunction r (T a)

xor :: T a -> T a -> CodeGenFunction r (T a)

inv :: T a -> CodeGenFunction r (T a)

Instances

Logic Bool

Logic Word8

Logic Word16

Logic Word32

Logic Word64

Logic Bool8

Positive n => Logic (WordN n)

(IsInteger w, IsConst w) => Logic (T w i)

(Positive n, Logic a) => Logic (Vector n a)

Logic a => Logic (Tagged tag a)

class BitShift a where

Methods

shl :: T a -> T a -> CodeGenFunction r (T a)

shr :: T a -> T a -> CodeGenFunction r (T a)

Instances

BitShift Int

BitShift Int8

BitShift Int16

BitShift Int32

BitShift Int64

BitShift Word

BitShift Word8

BitShift Word16

BitShift Word32

BitShift Word64

(Positive n, BitShift a) => BitShift (Vector n a)

class PseudoRing a => Integral a where

Methods

idiv :: T a -> T a -> CodeGenFunction r (T a)

irem :: T a -> T a -> CodeGenFunction r (T a)

Instances

Integral Int

Integral Int32

Integral Int64

Integral Word

Integral Word32

Integral Word64

Integral a => Integral (Tagged tag a)

fromIntegral :: (NativeInteger i ir, NativeFloating a ar) => T i -> CodeGenFunction r (T a)