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

Maintainer | diagrams-discuss@googlegroups.com
Safe Haskell | None

Diagrams.Prelude

Contents

- Core library
- Standard library
- Convenience re-exports

Description

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

Synopsis

- module Diagrams.Core
- module Diagrams.Attributes
- module Diagrams.Align
- module Diagrams.Combinators
- module Diagrams.Located
- module Diagrams.Segment
- module Diagrams.Trail
- module Diagrams.Parametric
- module Diagrams.TrailLike
- module Diagrams.Path
- module Diagrams.CubicSpline
- module Diagrams.Transform
- module Diagrams.BoundingBox
- module Diagrams.Names
- module Diagrams.Envelope
- module Diagrams.Trace
- module Diagrams.Query
- module Diagrams.Points
- module Diagrams.TwoD
- module Diagrams.Animation
- module Diagrams.Util
- module Data.Colour
- module Data.Colour.Names
- module Data.Semigroup
- module Data.VectorSpace
- module Data.AffineSpace
- module Data.Active
- class Functor f => Applicative f where
  - pure :: a -> f a
  - (<*>) :: f (a -> b) -> f a -> f b
  - (*>) :: f a -> f b -> f b
  - (<*) :: f a -> f b -> f a
- (*>) :: Applicative f => forall a b. f a -> f b -> f b
- (<*) :: Applicative f => forall a b. f a -> f b -> f a
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- (<$) :: Functor f => forall a b. a -> f b -> f a
- liftA :: Applicative f => (a -> b) -> f a -> f b
- liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

# Core library

The core definitions of transformations, diagrams, backends, and so on.

module Diagrams.Core

# Standard library

Attributes (color, line style, etc.) and styles.

module Diagrams.Attributes

Alignment of diagrams relative to their envelopes.

module Diagrams.Align

Combining multiple diagrams into one.

module Diagrams.Combinators

Giving concrete locations to translation-invariant things.

module Diagrams.Located

Linear and cubic bezier segments.

module Diagrams.Segment

Trails.

module Diagrams.Trail

Parametrization of segments and trails.

module Diagrams.Parametric

Trail-like things.

module Diagrams.TrailLike

Paths.

module Diagrams.Path

Cubic splines.

module Diagrams.CubicSpline

Some additional transformation-related functions, like conjugation of transformations.

module Diagrams.Transform

Convenient definitions and utilities for working with good old-fashioned, axis-aligned bounding boxes.

module Diagrams.BoundingBox

Giving names to subdiagrams and later retrieving subdiagrams by name.

module Diagrams.Names

Envelopes, aka functional bounding regions.

module Diagrams.Envelope

Traces, aka embedded raytracers, for finding points on the boundary of a diagram.

module Diagrams.Trace

A query is a function that maps points in a vector space to values in some monoid; they can be used to annotate the points of a diagram with some values.

module Diagrams.Query

Utilities for working with points.

module Diagrams.Points

A wide range of things (shapes, transformations, combinators) specific to creating two-dimensional diagrams.

module Diagrams.TwoD

Tools for making animations.

module Diagrams.Animation

Various utility definitions.

module Diagrams.Util

# Convenience re-exports

For representing and operating on colors.

module Data.Colour

A large list of color names.

module Data.Colour.Names

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

module Data.Semigroup

For computing with vectors.

module Data.VectorSpace

For computing with points and vectors.

module Data.AffineSpace

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

module Data.Active

class Functor f => Applicative f where

A functor with application, providing operations to

- embed pure expressions (`pure`), and
- sequence computations and combine their results (`<*>`).

A minimal complete definition must include implementations of these functions satisfying the following laws:

identity
  ``pure` `id` `<*>` v = v`
composition
  ``pure` (.) `<*>` u `<*>` v `<*>` w = u `<*>` (v `<*>` w)`
homomorphism
  ``pure` f `<*>` `pure` x = `pure` (f x)`
interchange
  `u `<*>` `pure` y = `pure` (`$` y) `<*>` u`

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

          u *> v = pure (const id) <*> u <*> v
          u <* v = pure const <*> u <*> v

As a consequence of these laws, the `Functor` instance for `f` will satisfy

          fmap f x = pure f <*> x

If `f` is also a `Monad`, it should satisfy ``pure` = `return`` and `(`<*>`) = `ap`` (which implies that `pure` and `<*>` satisfy the applicative functor laws).

Methods

pure :: a -> f a

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b

Sequential application.

(*>) :: f a -> f b -> f b

Sequence actions, discarding the value of the first argument.

(<*) :: f a -> f b -> f a

Sequence actions, discarding the value of the second argument.

Instances

Applicative [] |
Applicative IO |
Applicative Active |
Applicative ZipList |
Applicative STM |
Applicative ReadPrec |
Applicative ReadP |
Applicative Maybe |
Applicative RGB |
Applicative Id |
Applicative Option |
Applicative NonEmpty |
Applicative Sum |
Applicative ((->) a) |
Applicative (Either e) |
Monoid a => Applicative ((,) a) |
Applicative (ST s) |
Monoid m => Applicative (Const m) |
Monad m => Applicative (WrappedMonad m) |
Applicative (ST s) |
Arrow a => Applicative (ArrowMonad a) |
Applicative (State s) |
Applicative (Query v) |
HasTrie a => Applicative (:->: a) |
Arrow a => Applicative (WrappedArrow a b) |
(Functor m, Monad m) => Applicative (ErrorT e m) |

(*>) :: Applicative f => forall a b. f a -> f b -> f b

Sequence actions, discarding the value of the first argument.

(<*) :: Applicative f => forall a b. f a -> f b -> f a

Sequence actions, discarding the value of the second argument.

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

An infix synonym for `fmap`.

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

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.

liftA :: Applicative f => (a -> b) -> f a -> f b

Lift a function to actions. This function may be used as a value for `fmap` in a `Functor` instance.

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c

Lift a binary function to actions.

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

Lift a ternary function to actions.