Many sorts of objects have an associated vector space in which they live. The type function V maps from objects to their associated vector space.

Point is a newtype wrapper around vectors that we wish to treat as points, so we don't get them mixed up. The distinction is important: translations affect points, but leave vectors unchanged. Points are instances of the AffineSpace class from Data.AffineSpace.

The origin of the vector space v.

Scale a point by a scalar.

Produce a vector with the specified length in the same direction as the given vector.

(v1 :-: v2) is a linear map paired with its inverse.

Create an invertible linear map from two functions which are assumed to be linear inverses.

Invert a linear map.

Apply a linear map to a vector.

General (affine) transformations, represented by an invertible linear map, its transpose, and a vector representing a translation component.

Invert a transformation.

Get the transpose of a transformation (ignoring the translation component).

Get the translational component of a transformation.

Apply a transformation to a vector. Note that any translational component of the transformation will not affect the vector, since vectors are invariant under translation.

Apply a transformation to a point.

Create a general affine transformation from an invertible linear transformation and its transpose. The translational component is assumed to be zero.

Create a translation.

Translate by a vector.

Translate the object by the translation that sends the origin to the given point. Note that this is dual to moveOriginTo, i.e. we should have

 moveTo (origin .^+ v) === moveOriginTo (origin .^- v)

For types which are also Transformable, this is essentially the same as translate, i.e.

 moveTo (origin .^+ v) === translate v

Create a uniform scaling transformation.

Scale uniformly in every dimension by the given scalar.

Type class for things t which can be transformed.

A (qualified) name is a (possibly empty) sequence of atomic names. Atomic names can be either numbers or arbitrary strings. Numeric names are provided for convenience in naming lists of things, such as a row of ten squares, or the vertices of a path.

Instaces of IsName are things which can be converted to names.

Instances of Qualifiable are things which can be qualified by prefixing them with a name.

Convenient operator for writing complete names in the form a1 |> a2 |> a3 ||> a4. In particular, n1 ||> n2 is equivalent to n1 |> toName n2.

A NameMap is a map from names to points, possibly with multiple points associated with each name.

Construct a NameMap from a list of (name, point) pairs.

Give a name to a point.

Look for the given name in a name map, returning a list of points associated with that name. If no names match the given name exactly, return all the points associated with names of which the given name is a suffix.

Every attribute must be an instance of AttributeClass, which simply guarantees a Typeable constraint.

An existential wrapper type to hold attributes.

Wrap up an attribute.

Unwrap an unknown Attribute type, performing a dynamic (but safe) check on the type of the result. If the required type matches the type of the attribute, the attribute value is returned wrapped in Just; if the types do not match, Nothing is returned.

A Style is a heterogeneous collection of attributes, containing at most one attribute of any given type.

Type class for things which have a style.

Extract an attribute from a style of a particular type. If the style contains an attribute of the requested type, it will be returned wrapped in Just; otherwise, Nothing is returned.

Add a new attribute to a style, or replace the old attribute of the same type if one exists.

Attempt to add a new attribute to a style, but if an attribute of the same type already exists, do not replace it.

Apply an attribute to an instance of HasStyle (such as a diagram or a style). applyAttr has no effect if an attribute of the same type already exists.

Every diagram comes equipped with a bounding function. Intuitively, the bounding function for a diagram tells us the minimum distance we have to go in a given direction to get to a (hyper)plane entirely containing the diagram on one side of it. Formally, given a vector v, it returns a scalar s such that

• for every vector u with its endpoint inside the diagram, if the projection of u onto v is s' *^ v, then s' <= s.
• s is the smallest such scalar.

This could probably be expressed in terms of a Galois connection; this is left as an exercise for the reader.

Essentially, bounding functions are a functional representation of (a conservative approximation to) convex bounding regions. The idea for this representation came from Sebastian Setzer; see http://byorgey.wordpress.com/2009/10/28/collecting-attributes/#comment-2030.

Boundable abstracts over things which can be bounded.

Compute the point along the boundary in the given direction.

Compute the diameter of a boundable object along a particular vector.

Compute the radius (1/2 the diameter) of a boundable object along a particular vector.

Class of types which have an intrinsic notion of a "local origin", i.e. things which are not invariant under translation, and which allow the origin to be moved.

One might wonder why not just use Transformable instead of having a separate class for HasOrigin; indeed, for types which are instances of both we should have the identity

 moveOriginTo (origin .^+ v) === translate (negateV v)

The reason is that some things (e.g. vectors, Trails) are transformable but are translationally invariant, i.e. have no origin.

Move the local origin by a relative vector.

A query is a function that maps points in a vector space to values in some monoid. Queries naturally form a monoid, with two queries being combined pointwise.

The idea for annotating diagrams with monoidal queries came from the graphics-drawingcombinators package, http://hackage.haskell.org/package/graphics-drawingcombinators.

A value of type Prim b v is an opaque (existentially quantified) primitive which backend b knows how to render in vector space v.

The null primitive, which every backend can render by doing nothing.

The fundamental diagram type is represented by trees of primitives with various monoidal annotations.

Create a diagram from a single primitive, along with a bounding region, name map, and query function.

The default sort of diagram is one where sampling at a point simply tells you whether that point is occupied or not. Transforming a default diagram into one with more interesting annotations can be done via the Functor instance of AnnDiagram b.

Extract a list of primitives from a diagram, together with their associated transformations and styles.

Get the bounds of a diagram.

Get the name map of a diagram.

Get the query function associated with a diagram.

Sample a diagram's query function at a given point.

Attach a name to a diagram.

Given a name and a diagram transformation indexed by a point, perform the transformation using the first point associated with the name, or perform the identity transformation if the name does not exist.

By default, diagram attributes are not affected by transformations. This means, for example, that lw 0.01 circle and scale 2 (lw 0.01 circle) will be drawn with lines of the same width, and scaleY 3 circle will be an ellipse drawn with a uniform line. Once a diagram is frozen, however, transformations do affect attributes, so, for example, scale 2 (freeze (lw 0.01 circle)) will be drawn with a line twice as thick as lw 0.01 circle, and scaleY 3 (freeze circle) will be drawn with a "stretched", variable-width line.

Another way of thinking about it is that pre-freeze, we are transforming the "abstract idea" of a diagram, and the transformed version is then drawn; when doing a freeze, we produce a concrete drawing of the diagram, and it is this visual representation itself which is acted upon by subsequent transformations.

A convenient synonym for mappend on diagrams, designed to be used infix (to help remember which diagram goes on top of which when combining them, namely, the first on top of the second).

Abstract diagrams are rendered to particular formats by backends. Each backend/vector space combination must be an instance of the Backend class. A minimal complete definition consists of the three associated types and implementations for withStyle and doRender.

A class for backends which support rendering multiple diagrams, e.g. to a multi-page pdf or something similar.

The Renderable type class connects backends to primitives which they know how to render.

HasLinearMap is a poor man's class constraint synonym, just to help shorten some of the ridiculously long constraint sets.

When dealing with bounding regions we often want scalars to be an ordered field (i.e. support all four arithmetic operations and be totally ordered) so we introduce this class as a convenient shorthand.