Data.Array.Accelerate.Data.Functor

A functor performs a uniform action over a parameterised type

This is essentially the same as the standard Haskell Functor class, lifted to Accelerate Exp terms.

Since: 1.2.0.0

Documentation

class Functor f where

The Functor class is used for scalar types which can be mapped over. Instances of Functor should satisfy the following laws:

fmap id      == id
fmap (f . g) == fmap f . fmap g

Minimal complete definition

fmap

Methods

fmap :: (Elt a, Elt b, Elt (f a), Elt (f b)) => (Exp a -> Exp b) -> Exp (f a) -> Exp (f b)

(<$) :: (Elt a, Elt b, Elt (f a), Elt (f b)) => Exp a -> Exp (f b) -> Exp (f a) infixl 4

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Instances

Functor Maybe

Defined in Data.Array.Accelerate.Data.Maybe

Methods

fmap :: (Elt a, Elt b, Elt (Maybe a), Elt (Maybe b)) => (Exp a -> Exp b) -> Exp (Maybe a) -> Exp (Maybe b)

(<$) :: (Elt a, Elt b, Elt (Maybe a), Elt (Maybe b)) => Exp a -> Exp (Maybe b) -> Exp (Maybe a)

Functor Complex

Since: 1.2.0.0

Defined in Data.Array.Accelerate.Data.Complex

Methods

fmap :: (Elt a, Elt b, Elt (Complex a), Elt (Complex b)) => (Exp a -> Exp b) -> Exp (Complex a) -> Exp (Complex b)

(<$) :: (Elt a, Elt b, Elt (Complex a), Elt (Complex b)) => Exp a -> Exp (Complex b) -> Exp (Complex a)

Functor Min

Defined in Data.Array.Accelerate.Data.Functor

Methods

fmap :: (Elt a, Elt b, Elt (Min a), Elt (Min b)) => (Exp a -> Exp b) -> Exp (Min a) -> Exp (Min b)

(<$) :: (Elt a, Elt b, Elt (Min a), Elt (Min b)) => Exp a -> Exp (Min b) -> Exp (Min a)

Functor Max

Defined in Data.Array.Accelerate.Data.Functor

Methods

fmap :: (Elt a, Elt b, Elt (Max a), Elt (Max b)) => (Exp a -> Exp b) -> Exp (Max a) -> Exp (Max b)

(<$) :: (Elt a, Elt b, Elt (Max a), Elt (Max b)) => Exp a -> Exp (Max b) -> Exp (Max a)

Functor Sum

Defined in Data.Array.Accelerate.Data.Functor

Methods

fmap :: (Elt a, Elt b, Elt (Sum a), Elt (Sum b)) => (Exp a -> Exp b) -> Exp (Sum a) -> Exp (Sum b)

(<$) :: (Elt a, Elt b, Elt (Sum a), Elt (Sum b)) => Exp a -> Exp (Sum b) -> Exp (Sum a)

Functor Product

Defined in Data.Array.Accelerate.Data.Functor

Methods

fmap :: (Elt a, Elt b, Elt (Product a), Elt (Product b)) => (Exp a -> Exp b) -> Exp (Product a) -> Exp (Product b)

(<$) :: (Elt a, Elt b, Elt (Product a), Elt (Product b)) => Exp a -> Exp (Product b) -> Exp (Product a)

Elt a => Functor (Either a)

Defined in Data.Array.Accelerate.Data.Either

Methods

fmap :: (Elt a0, Elt b, Elt (Either a a0), Elt (Either a b)) => (Exp a0 -> Exp b) -> Exp (Either a a0) -> Exp (Either a b)

(<$) :: (Elt a0, Elt b, Elt (Either a a0), Elt (Either a b)) => Exp a0 -> Exp (Either a b) -> Exp (Either a a0)

(<$>) :: (Functor f, Elt a, Elt b, Elt (f a), Elt (f b)) => (Exp a -> Exp b) -> Exp (f a) -> Exp (f b) infixl 4

An infix synonym for fmap

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (Exp a -> Exp b) -> Exp a     -> Exp b
(<$>) :: Functor f => (Exp a -> Exp b) -> Exp (f a) -> Exp (f b)

Whereas $ is function application, <$> is function application lifted over a Functor.

($>) :: (Functor f, Elt a, Elt b, Elt (f a), Elt (f b)) => Exp (f a) -> Exp b -> Exp (f b) infixl 4

A flipped version of (<$).

void :: (Functor f, Elt a, Elt (f a), Elt (f ())) => Exp (f a) -> Exp (f ())

void value discards or ignores the result of evaluation.