diagrams-lib-1.4.2.3: Embedded domain-specific language for declarative graphics

Copyright(c) 2011-2015 diagrams-lib team (see LICENSE)
LicenseBSD-style (see LICENSE)
Maintainerdiagrams-discuss@googlegroups.com
Safe HaskellNone
LanguageHaskell2010

Diagrams.Prelude

Contents

Description

A module to re-export most of the functionality of the diagrams core and standard library.

Synopsis

Diagrams library

Exports from this library for working with diagrams.

module Diagrams

Convenience re-exports from other packages

For working with default values. Diagrams also exports with, an alias for def.

For representing and operating on colors.

alphaChannel :: AlphaColour a -> a #

Returns the opacity of an AlphaColour.

blend :: (Num a, AffineSpace f) => a -> f a -> f a -> f a #

Compute the weighted average of two points. e.g.

blend 0.4 a b = 0.4*a + 0.6*b

The weight can be negative, or greater than 1.0; however, be aware that non-convex combinations may lead to out of gamut colours.

withOpacity :: Num a => Colour a -> a -> AlphaColour a #

Creates an AlphaColour from a Colour with a given opacity.

c `withOpacity` o == dissolve o (opaque c) 

dissolve :: Num a => a -> AlphaColour a -> AlphaColour a #

Returns an AlphaColour more transparent by a factor of o.

opaque :: Num a => Colour a -> AlphaColour a #

Creates an opaque AlphaColour from a Colour.

alphaColourConvert :: (Fractional b, Real a) => AlphaColour a -> AlphaColour b #

Change the type used to represent the colour coordinates.

transparent :: Num a => AlphaColour a #

This AlphaColour is entirely transparent and has no associated colour channel.

black :: Num a => Colour a #

colourConvert :: (Fractional b, Real a) => Colour a -> Colour b #

Change the type used to represent the colour coordinates.

data Colour a #

This type represents the human preception of colour. The a parameter is a numeric type used internally for the representation.

The Monoid instance allows one to add colours, but beware that adding colours can take you out of gamut. Consider using blend whenever possible.

Instances
AffineSpace Colour 
Instance details

Defined in Data.Colour.Internal

Methods

affineCombo :: Num a => [(a, Colour a)] -> Colour a -> Colour a #

ColourOps Colour 
Instance details

Defined in Data.Colour.Internal

Methods

over :: Num a => AlphaColour a -> Colour a -> Colour a #

darken :: Num a => a -> Colour a -> Colour a #

Eq a => Eq (Colour a) 
Instance details

Defined in Data.Colour.Internal

Methods

(==) :: Colour a -> Colour a -> Bool #

(/=) :: Colour a -> Colour a -> Bool #

Num a => Semigroup (Colour a) 
Instance details

Defined in Data.Colour.Internal

Methods

(<>) :: Colour a -> Colour a -> Colour a #

sconcat :: NonEmpty (Colour a) -> Colour a #

stimes :: Integral b => b -> Colour a -> Colour a #

Num a => Monoid (Colour a) 
Instance details

Defined in Data.Colour.Internal

Methods

mempty :: Colour a #

mappend :: Colour a -> Colour a -> Colour a #

mconcat :: [Colour a] -> Colour a #

a ~ Double => Color (Colour a) # 
Instance details

Defined in Diagrams.Attributes

Parseable (Colour Double) #

Parse Colour Double as either a named color from Data.Colour.Names or a hexadecimal color.

Instance details

Defined in Diagrams.Backend.CmdLine

data AlphaColour a #

This type represents a Colour that may be semi-transparent.

The Monoid instance allows you to composite colours.

x `mappend` y == x `over` y

To get the (pre-multiplied) colour channel of an AlphaColour c, simply composite c over black.

c `over` black
Instances
AffineSpace AlphaColour 
Instance details

Defined in Data.Colour.Internal

Methods

affineCombo :: Num a => [(a, AlphaColour a)] -> AlphaColour a -> AlphaColour a #

ColourOps AlphaColour 
Instance details

Defined in Data.Colour.Internal

Methods

over :: Num a => AlphaColour a -> AlphaColour a -> AlphaColour a #

darken :: Num a => a -> AlphaColour a -> AlphaColour a #

Eq a => Eq (AlphaColour a) 
Instance details

Defined in Data.Colour.Internal

Num a => Semigroup (AlphaColour a)

AlphaColour forms a monoid with over and transparent.

Instance details

Defined in Data.Colour.Internal

Num a => Monoid (AlphaColour a) 
Instance details

Defined in Data.Colour.Internal

a ~ Double => Color (AlphaColour a) # 
Instance details

Defined in Diagrams.Attributes

Parseable (AlphaColour Double) #

Parse AlphaColour Double as either a named color from Data.Colour.Names or a hexadecimal color.

Instance details

Defined in Diagrams.Backend.CmdLine

class ColourOps (f :: Type -> Type) where #

Minimal complete definition

over, darken

Methods

darken :: Num a => a -> f a -> f a #

darken s c blends a colour with black without changing it's opacity.

For Colour, darken s c = blend s c mempty

Instances
ColourOps Colour 
Instance details

Defined in Data.Colour.Internal

Methods

over :: Num a => AlphaColour a -> Colour a -> Colour a #

darken :: Num a => a -> Colour a -> Colour a #

ColourOps AlphaColour 
Instance details

Defined in Data.Colour.Internal

Methods

over :: Num a => AlphaColour a -> AlphaColour a -> AlphaColour a #

darken :: Num a => a -> AlphaColour a -> AlphaColour a #

A large list of color names.

yellow :: (Ord a, Floating a) => Colour a #

whitesmoke :: (Ord a, Floating a) => Colour a #

white :: (Ord a, Floating a) => Colour a #

wheat :: (Ord a, Floating a) => Colour a #

violet :: (Ord a, Floating a) => Colour a #

turquoise :: (Ord a, Floating a) => Colour a #

tomato :: (Ord a, Floating a) => Colour a #

thistle :: (Ord a, Floating a) => Colour a #

teal :: (Ord a, Floating a) => Colour a #

steelblue :: (Ord a, Floating a) => Colour a #

snow :: (Ord a, Floating a) => Colour a #

slategrey :: (Ord a, Floating a) => Colour a #

slategray :: (Ord a, Floating a) => Colour a #

slateblue :: (Ord a, Floating a) => Colour a #

skyblue :: (Ord a, Floating a) => Colour a #

silver :: (Ord a, Floating a) => Colour a #

sienna :: (Ord a, Floating a) => Colour a #

seashell :: (Ord a, Floating a) => Colour a #

seagreen :: (Ord a, Floating a) => Colour a #

sandybrown :: (Ord a, Floating a) => Colour a #

salmon :: (Ord a, Floating a) => Colour a #

royalblue :: (Ord a, Floating a) => Colour a #

rosybrown :: (Ord a, Floating a) => Colour a #

red :: (Ord a, Floating a) => Colour a #

purple :: (Ord a, Floating a) => Colour a #

powderblue :: (Ord a, Floating a) => Colour a #

plum :: (Ord a, Floating a) => Colour a #

pink :: (Ord a, Floating a) => Colour a #

peru :: (Ord a, Floating a) => Colour a #

peachpuff :: (Ord a, Floating a) => Colour a #

papayawhip :: (Ord a, Floating a) => Colour a #

palegreen :: (Ord a, Floating a) => Colour a #

orchid :: (Ord a, Floating a) => Colour a #

orangered :: (Ord a, Floating a) => Colour a #

orange :: (Ord a, Floating a) => Colour a #

olivedrab :: (Ord a, Floating a) => Colour a #

olive :: (Ord a, Floating a) => Colour a #

oldlace :: (Ord a, Floating a) => Colour a #

navy :: (Ord a, Floating a) => Colour a #

moccasin :: (Ord a, Floating a) => Colour a #

mistyrose :: (Ord a, Floating a) => Colour a #

mintcream :: (Ord a, Floating a) => Colour a #

mediumblue :: (Ord a, Floating a) => Colour a #

maroon :: (Ord a, Floating a) => Colour a #

magenta :: (Ord a, Floating a) => Colour a #

linen :: (Ord a, Floating a) => Colour a #

limegreen :: (Ord a, Floating a) => Colour a #

lime :: (Ord a, Floating a) => Colour a #

lightpink :: (Ord a, Floating a) => Colour a #

lightgrey :: (Ord a, Floating a) => Colour a #

lightgreen :: (Ord a, Floating a) => Colour a #

lightgray :: (Ord a, Floating a) => Colour a #

lightcyan :: (Ord a, Floating a) => Colour a #

lightcoral :: (Ord a, Floating a) => Colour a #

lightblue :: (Ord a, Floating a) => Colour a #

lawngreen :: (Ord a, Floating a) => Colour a #

lavender :: (Ord a, Floating a) => Colour a #

khaki :: (Ord a, Floating a) => Colour a #

ivory :: (Ord a, Floating a) => Colour a #

indigo :: (Ord a, Floating a) => Colour a #

indianred :: (Ord a, Floating a) => Colour a #

hotpink :: (Ord a, Floating a) => Colour a #

honeydew :: (Ord a, Floating a) => Colour a #

green :: (Ord a, Floating a) => Colour a #

grey :: (Ord a, Floating a) => Colour a #

gray :: (Ord a, Floating a) => Colour a #

goldenrod :: (Ord a, Floating a) => Colour a #

gold :: (Ord a, Floating a) => Colour a #

ghostwhite :: (Ord a, Floating a) => Colour a #

gainsboro :: (Ord a, Floating a) => Colour a #

fuchsia :: (Ord a, Floating a) => Colour a #

firebrick :: (Ord a, Floating a) => Colour a #

dodgerblue :: (Ord a, Floating a) => Colour a #

dimgrey :: (Ord a, Floating a) => Colour a #

dimgray :: (Ord a, Floating a) => Colour a #

deeppink :: (Ord a, Floating a) => Colour a #

darkviolet :: (Ord a, Floating a) => Colour a #

darksalmon :: (Ord a, Floating a) => Colour a #

darkred :: (Ord a, Floating a) => Colour a #

darkorchid :: (Ord a, Floating a) => Colour a #

darkorange :: (Ord a, Floating a) => Colour a #

darkkhaki :: (Ord a, Floating a) => Colour a #

darkgrey :: (Ord a, Floating a) => Colour a #

darkgreen :: (Ord a, Floating a) => Colour a #

darkgray :: (Ord a, Floating a) => Colour a #

darkcyan :: (Ord a, Floating a) => Colour a #

darkblue :: (Ord a, Floating a) => Colour a #

cyan :: (Ord a, Floating a) => Colour a #

crimson :: (Ord a, Floating a) => Colour a #

cornsilk :: (Ord a, Floating a) => Colour a #

coral :: (Ord a, Floating a) => Colour a #

chocolate :: (Ord a, Floating a) => Colour a #

chartreuse :: (Ord a, Floating a) => Colour a #

cadetblue :: (Ord a, Floating a) => Colour a #

burlywood :: (Ord a, Floating a) => Colour a #

brown :: (Ord a, Floating a) => Colour a #

blueviolet :: (Ord a, Floating a) => Colour a #

blue :: (Ord a, Floating a) => Colour a #

bisque :: (Ord a, Floating a) => Colour a #

beige :: (Ord a, Floating a) => Colour a #

azure :: (Ord a, Floating a) => Colour a #

aquamarine :: (Ord a, Floating a) => Colour a #

aqua :: (Ord a, Floating a) => Colour a #

aliceblue :: (Ord a, Floating a) => Colour a #

readColourName :: (Monad m, Ord a, Floating a) => String -> m (Colour a) #

black :: Num a => Colour a #

Specify your own colours.

Semigroups and monoids show up all over the place, so things from Data.Semigroup and Data.Monoid often come in handy.

For computing with vectors.

For computing with points and vectors.

For computing with dot products and norm.

For working with Active (i.e. animated) things.

Most of the lens package. The following functions are not exported from lens because they either conflict with diagrams or may conflict with other libraries:

class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

naturality
t . traverse f = traverse (t . f) for every applicative transformation t
identity
traverse Identity = Identity
composition
traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality
t . sequenceA = sequenceA . fmap t for every applicative transformation t
identity
sequenceA . fmap Identity = Identity
composition
sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

and the identity functor Identity and composition of functors Compose are defined as

  newtype Identity a = Identity a

  instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

  instance Applicative Identity where
    pure x = Identity x
    Identity f <*> Identity x = Identity (f x)

  newtype Compose f g a = Compose (f (g a))

  instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
    pure x = Compose (pure (pure x))
    Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(The naturality law is implied by parametricity.)

Instances are similar to Functor, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

Instances
Traversable []

Since: base-2.1

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> [a] -> f [b] #

sequenceA :: Applicative f => [f a] -> f [a] #

mapM :: Monad m => (a -> m b) -> [a] -> m [b] #

sequence :: Monad m => [m a] -> m [a] #

Traversable Maybe

Since: base-2.1

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) #

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) #

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) #

sequence :: Monad m => Maybe (m a) -> m (Maybe a) #

Traversable Par1

Since: base-4.9.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) #

sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) #

mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) #

sequence :: Monad m => Par1 (m a) -> m (Par1 a) #

Traversable Complex

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

Methods

traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) #

sequenceA :: Applicative f => Complex (f a) -> f (Complex a) #

mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) #

sequence :: Monad m => Complex (m a) -> m (Complex a) #

Traversable Min

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) #

sequenceA :: Applicative f => Min (f a) -> f (Min a) #

mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) #

sequence :: Monad m => Min (m a) -> m (Min a) #

Traversable Max

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) #

sequenceA :: Applicative f => Max (f a) -> f (Max a) #

mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) #

sequence :: Monad m => Max (m a) -> m (Max a) #

Traversable First

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> First a -> f (First b) #

sequenceA :: Applicative f => First (f a) -> f (First a) #

mapM :: Monad m => (a -> m b) -> First a -> m (First b) #

sequence :: Monad m => First (m a) -> m (First a) #

Traversable Last

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) #

sequenceA :: Applicative f => Last (f a) -> f (Last a) #

mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) #

sequence :: Monad m => Last (m a) -> m (Last a) #

Traversable Option

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) #

sequenceA :: Applicative f => Option (f a) -> f (Option a) #

mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) #

sequence :: Monad m => Option (m a) -> m (Option a) #

Traversable ZipList

Since: base-4.9.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) #

sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) #

mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) #

sequence :: Monad m => ZipList (m a) -> m (ZipList a) #

Traversable Identity

Since: base-4.9.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) #

sequenceA :: Applicative f => Identity (f a) -> f (Identity a) #

mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) #

sequence :: Monad m => Identity (m a) -> m (Identity a) #

Traversable First

Since: base-4.8.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> First a -> f (First b) #

sequenceA :: Applicative f => First (f a) -> f (First a) #

mapM :: Monad m => (a -> m b) -> First a -> m (First b) #

sequence :: Monad m => First (m a) -> m (First a) #

Traversable Last

Since: base-4.8.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) #

sequenceA :: Applicative f => Last (f a) -> f (Last a) #

mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) #

sequence :: Monad m => Last (m a) -> m (Last a) #

Traversable Dual

Since: base-4.8.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) #

sequenceA :: Applicative f => Dual (f a) -> f (Dual a) #

mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) #

sequence :: Monad m => Dual (m a) -> m (Dual a) #

Traversable Sum

Since: base-4.8.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) #

sequenceA :: Applicative f => Sum (f a) -> f (Sum a) #

mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) #

sequence :: Monad m => Sum (m a) -> m (Sum a) #

Traversable Product

Since: base-4.8.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) #

sequenceA :: Applicative f => Product (f a) -> f (Product a) #

mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) #

sequence :: Monad m => Product (m a) -> m (Product a) #

Traversable Down

Since: base-4.12.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) #

sequenceA :: Applicative f => Down (f a) -> f (Down a) #

mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) #

sequence :: Monad m => Down (m a) -> m (Down a) #

Traversable NonEmpty

Since: base-4.9.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) #

sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) #

mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) #

sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #

Traversable IntMap 
Instance details

Defined in Data.IntMap.Internal

Methods

traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) #

sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) #

mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) #

sequence :: Monad m => IntMap (m a) -> m (IntMap a) #

Traversable Tree 
Instance details

Defined in Data.Tree

Methods

traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b) #

sequenceA :: Applicative f => Tree (f a) -> f (Tree a) #

mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b) #

sequence :: Monad m => Tree (m a) -> m (Tree a) #

Traversable Seq 
Instance details

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) #

sequenceA :: Applicative f => Seq (f a) -> f (Seq a) #

mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) #

sequence :: Monad m => Seq (m a) -> m (Seq a) #

Traversable FingerTree 
Instance details

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) #

sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) #

mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) #

sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) #

Traversable Digit 
Instance details

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) #

sequenceA :: Applicative f => Digit (f a) -> f (Digit a) #

mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) #

sequence :: Monad m => Digit (m a) -> m (Digit a) #

Traversable Node 
Instance details

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) #

sequenceA :: Applicative f => Node (f a) -> f (Node a) #

mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) #

sequence :: Monad m => Node (m a) -> m (Node a) #

Traversable Elem 
Instance details

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) #

sequenceA :: Applicative f => Elem (f a) -> f (Elem a) #

mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) #

sequence :: Monad m => Elem (m a) -> m (Elem a) #

Traversable ViewL 
Instance details

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) #

sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) #

mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) #

sequence :: Monad m => ViewL (m a) -> m (ViewL a) #

Traversable ViewR 
Instance details

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) #

sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) #

mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) #

sequence :: Monad m => ViewR (m a) -> m (ViewR a) #

Traversable Interval 
Instance details

Defined in Numeric.Interval.Kaucher

Methods

traverse :: Applicative f => (a -> f b) -> Interval a -> f (Interval b) #

sequenceA :: Applicative f => Interval (f a) -> f (Interval a) #

mapM :: Monad m => (a -> m b) -> Interval a -> m (Interval b) #

sequence :: Monad m => Interval (m a) -> m (Interval a) #

Traversable Vector 
Instance details

Defined in Data.Vector

Methods

traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) #

sequenceA :: Applicative f => Vector (f a) -> f (Vector a) #

mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) #

sequence :: Monad m => Vector (m a) -> m (Vector a) #

Traversable Plucker 
Instance details

Defined in Linear.Plucker

Methods

traverse :: Applicative f => (a -> f b) -> Plucker a -> f (Plucker b) #

sequenceA :: Applicative f => Plucker (f a) -> f (Plucker a) #

mapM :: Monad m => (a -> m b) -> Plucker a -> m (Plucker b) #

sequence :: Monad m => Plucker (m a) -> m (Plucker a) #

Traversable Quaternion 
Instance details

Defined in Linear.Quaternion

Methods

traverse :: Applicative f => (a -> f b) -> Quaternion a -> f (Quaternion b) #

sequenceA :: Applicative f => Quaternion (f a) -> f (Quaternion a) #

mapM :: Monad m => (a -> m b) -> Quaternion a -> m (Quaternion b) #

sequence :: Monad m => Quaternion (m a) -> m (Quaternion a) #

Traversable V0 
Instance details

Defined in Linear.V0

Methods

traverse :: Applicative f => (a -> f b) -> V0 a -> f (V0 b) #

sequenceA :: Applicative f => V0 (f a) -> f (V0 a) #

mapM :: Monad m => (a -> m b) -> V0 a -> m (V0 b) #

sequence :: Monad m => V0 (m a) -> m (V0 a) #

Traversable V4 
Instance details

Defined in Linear.V4

Methods

traverse :: Applicative f => (a -> f b) -> V4 a -> f (V4 b) #

sequenceA :: Applicative f => V4 (f a) -> f (V4 a) #

mapM :: Monad m => (a -> m b) -> V4 a -> m (V4 b) #

sequence :: Monad m => V4 (m a) -> m (V4 a) #

Traversable V3 
Instance details

Defined in Linear.V3

Methods

traverse :: Applicative f => (a -> f b) -> V3 a -> f (V3 b) #

sequenceA :: Applicative f => V3 (f a) -> f (V3 a) #

mapM :: Monad m => (a -> m b) -> V3 a -> m (V3 b) #

sequence :: Monad m => V3 (m a) -> m (V3 a) #

Traversable V2 
Instance details

Defined in Linear.V2

Methods

traverse :: Applicative f => (a -> f b) -> V2 a -> f (V2 b) #

sequenceA :: Applicative f => V2 (f a) -> f (V2 a) #

mapM :: Monad m => (a -> m b) -> V2 a -> m (V2 b) #

sequence :: Monad m => V2 (m a) -> m (V2 a) #

Traversable V1 
Instance details

Defined in Linear.V1

Methods

traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) #

sequenceA :: Applicative f => V1 (f a) -> f (V1 a) #

mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) #

sequence :: Monad m => V1 (m a) -> m (V1 a) #

Traversable Split 
Instance details

Defined in Data.Monoid.Split

Methods

traverse :: Applicative f => (a -> f b) -> Split a -> f (Split b) #

sequenceA :: Applicative f => Split (f a) -> f (Split a) #

mapM :: Monad m => (a -> m b) -> Split a -> m (Split b) #

sequence :: Monad m => Split (m a) -> m (Split a) #

Traversable Recommend 
Instance details

Defined in Data.Monoid.Recommend

Methods

traverse :: Applicative f => (a -> f b) -> Recommend a -> f (Recommend b) #

sequenceA :: Applicative f => Recommend (f a) -> f (Recommend a) #

mapM :: Monad m => (a -> m b) -> Recommend a -> m (Recommend b) #

sequence :: Monad m => Recommend (m a) -> m (Recommend a) #

Traversable Deletable 
Instance details

Defined in Data.Monoid.Deletable

Methods

traverse :: Applicative f => (a -> f b) -> Deletable a -> f (Deletable b) #

sequenceA :: Applicative f => Deletable (f a) -> f (Deletable a) #

mapM :: Monad m => (a -> m b) -> Deletable a -> m (Deletable b) #

sequence :: Monad m => Deletable (m a) -> m (Deletable a) #

Traversable SmallArray 
Instance details

Defined in Data.Primitive.SmallArray

Methods

traverse :: Applicative f => (a -> f b) -> SmallArray a -> f (SmallArray b) #

sequenceA :: Applicative f => SmallArray (f a) -> f (SmallArray a) #

mapM :: Monad m => (a -> m b) -> SmallArray a -> m (SmallArray b) #

sequence :: Monad m => SmallArray (m a) -> m (SmallArray a) #

Traversable Array 
Instance details

Defined in Data.Primitive.Array

Methods

traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b) #

sequenceA :: Applicative f => Array (f a) -> f (Array a) #

mapM :: Monad m => (a -> m b) ->