Data.Array.Accelerate.Utility.Lift.Run

Simplify running accelerate functions with multiple curried array and expression arguments.

Documentation

class C f where

If you have a function:

f :: Exp a -> (Acc b, Acc c) -> (Acc d, Acc e)

you cannot run this immediately using run1, since run1 expects a function with a single Acc parameter and a single Acc result. Using the with function you can just run f as is:

with run1 f :: a -> (b,c) -> (d,e)

Minimal complete definition

with1

Associated Types

type Arguments a f

type Result f

type Plain f

Methods

with1 :: Arrays a => ((Acc (Arguments a f) -> Acc (Result f)) -> Arguments a f -> Result f) -> (Acc a -> f) -> a -> Plain f

Instances

C (Acc r)

Associated Types

type Arguments a (Acc r) :: *

type Result (Acc r) :: *

type Plain (Acc r) :: *

Methods

with1 :: Arrays a => ((Acc (Arguments a (Acc r)) -> Acc (Result (Acc r))) -> Arguments a (Acc r) -> Result (Acc r)) -> (Acc a -> Acc r) -> a -> Plain (Acc r)

(Argument arg, C f) => C (arg -> f)

Associated Types

type Arguments a (arg -> f) :: *

type Result (arg -> f) :: *

type Plain (arg -> f) :: *

Methods

with1 :: Arrays a => ((Acc (Arguments a (arg -> f)) -> Acc (Result (arg -> f))) -> Arguments a (arg -> f) -> Result (arg -> f)) -> (Acc a -> arg -> f) -> a -> Plain (arg -> f)

(Lift Acc r, Arrays (Plain r), Lift Acc s, Arrays (Plain s)) => C (r, s)

Associated Types

type Arguments a (r, s) :: *

type Result (r, s) :: *

type Plain (r, s) :: *

Methods

with1 :: Arrays a => ((Acc (Arguments a (r, s)) -> Acc (Result (r, s))) -> Arguments a (r, s) -> Result (r, s)) -> (Acc a -> (r, s)) -> a -> Plain (r, s)

(Lift Acc r, Arrays (Plain r), Lift Acc s, Arrays (Plain s), Lift Acc t, Arrays (Plain t)) => C (r, s, t)

Associated Types

type Arguments a (r, s, t) :: *

type Result (r, s, t) :: *

type Plain (r, s, t) :: *

Methods

with1 :: Arrays a => ((Acc (Arguments a (r, s, t)) -> Acc (Result (r, s, t))) -> Arguments a (r, s, t) -> Result (r, s, t)) -> (Acc a -> (r, s, t)) -> a -> Plain (r, s, t)

with :: C f => ((Acc (Arguments () f) -> Acc (Result f)) -> Arguments () f -> Result f) -> f -> Plain f

class Arrays (Packed a) => Argument a where

Minimal complete definition

tunnel

Associated Types

type Packed a

type Unpacked a

Methods

tunnel :: (Unpacked a -> Packed a, Acc (Packed a) -> a)

Instances

Argument Z

Associated Types

type Packed Z :: *

type Unpacked Z :: *

Methods

tunnel :: (Unpacked Z -> Packed Z, Acc (Packed Z) -> Z)

Arrays a => Argument (Acc a)

Associated Types

type Packed (Acc a) :: *

type Unpacked (Acc a) :: *

Methods

tunnel :: (Unpacked (Acc a) -> Packed (Acc a), Acc (Packed (Acc a)) -> Acc a)

Elt a => Argument (Exp a)

Associated Types

type Packed (Exp a) :: *

type Unpacked (Exp a) :: *

Methods

tunnel :: (Unpacked (Exp a) -> Packed (Exp a), Acc (Packed (Exp a)) -> Exp a)

(Argument a, Argument b) => Argument (a, b)

Associated Types

type Packed (a, b) :: *

type Unpacked (a, b) :: *

Methods

tunnel :: (Unpacked (a, b) -> Packed (a, b), Acc (Packed (a, b)) -> (a, b))

(Unlift Exp a, Lift Exp a, Slice (Plain a), (~) * b (Exp Int)) => Argument ((:.) a b)

Associated Types

type Packed ((:.) a b) :: *

type Unpacked ((:.) a b) :: *

Methods

tunnel :: (Unpacked (a :. b) -> Packed (a :. b), Acc (Packed (a :. b)) -> a :. b)

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

Associated Types

type Packed (a, b, c) :: *

type Unpacked (a, b, c) :: *

Methods

tunnel :: (Unpacked (a, b, c) -> Packed (a, b, c), Acc (Packed (a, b, c)) -> (a, b, c))