LLVM.Extra.Multi.Value

Documentation

newtype T a

Constructors

Cons (Repr Value a)

Instances

C T

C a => Phi (T a)

Select a => Select (T a)

C a => Zero (T a)

C a => Undefined (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 (T a)

type Size T = D1

type CmpResult (T a) = T Bool

type Scalar (T a) = T (Scalar a)

type Composed (T a) = a

type Struct (T a) = Struct a

class C a where

Associated Types

type Repr f a :: *

Methods

cons :: a -> T a

undef :: T a

zero :: T a

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

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

Instances

C Bool

C Double

C Float

C Int8

C Int16

C Int32

C Int64

C Word8

C Word16

C Word32

C Word64

C ()

C (StablePtr a)

IsType a => C (Ptr a)

IsFunction a => C (FunPtr a)

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

(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 ~ Repr Value a) => al -> T a

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

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

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

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

consUnit :: (Repr Value a ~ ()) => a -> T a

undefUnit :: (Repr Value a ~ ()) => T a

zeroUnit :: (Repr Value a ~ ()) => T a

phisUnit :: (Repr Value a ~ ()) => BasicBlock -> T a -> CodeGenFunction r (T a)

addPhisUnit :: (Repr Value a ~ ()) => BasicBlock -> T a -> T a -> CodeGenFunction r ()

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)

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)

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)

class Compose multituple where

Associated Types

type Composed multituple

Methods

compose :: multituple -> T (Composed multituple)

A nested zip.

Instances

Compose (T a)

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

(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 (Atom a)

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

(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

Instances

type Decomposed f (Atom a) = f a

type Decomposed f (pa, pb) = (Decomposed f pa, Decomposed f pb)

type Decomposed f (pa, pb, pc) = (Decomposed f pa, Decomposed f pb, Decomposed f pc)

type Decomposed f (pa, pb, pc, pd) = (Decomposed f pa, Decomposed f pb, Decomposed f pc, Decomposed f pd)

type family PatternTuple pattern

Instances

type PatternTuple (Atom a) = a

type PatternTuple (pa, pb) = (PatternTuple pa, PatternTuple pb)

type PatternTuple (pa, pb, pc) = (PatternTuple pa, PatternTuple pb, PatternTuple pc)

type PatternTuple (pa, pb, pc, pd) = (PatternTuple pa, PatternTuple pb, PatternTuple pc, PatternTuple pd)

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)

type Decomposed f (Atom a) = f a

type PatternTuple (Atom a) = a

atom :: Atom a

lift1 :: (Repr Value a -> Repr Value b) -> T a -> T b

liftM0 :: Monad m => m (Repr Value a) -> m (T a)

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

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

liftM3 :: Monad m => (Repr Value a -> Repr Value b -> Repr Value c -> m (Repr Value 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

class IntegerConstant a => RationalConstant a where

Methods

fromRational' :: Rational -> T a

Instances

RationalConstant Double

RationalConstant Float

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 Int32

Additive Int64

Additive Word32

Additive Word64

class Additive a => PseudoRing a where

Methods

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

Instances

PseudoRing Double

PseudoRing Float

PseudoRing Int32

PseudoRing Int64

PseudoRing Word32

PseudoRing Word64

class PseudoRing a => Field a where

Methods

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

Instances

Field Double

Field Float

type family Scalar vector :: *

Instances

type Scalar Double = Double

type Scalar Float = Float

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

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 Int32

Real Int64

Real Word32

Real Word64

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

class Field a => Algebraic a where

Methods

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

Instances

Algebraic Double

Algebraic Float

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

class C a => Select a where

Methods

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

Instances

Select Double

Select Float

Select Int32

Select Int64

Select Word32

Select Word64

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

(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

class Comparison a => FloatingComparison a where

Methods

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

Instances

FloatingComparison Float

class 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

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 Int32

Integral Int64

Integral Word32

Integral Word64