Wumpus.Basic.Kernel.Base.BaseDefs

The elementary base types and classes.

A semigroup class

class OPlus t where

A Semigroup class.

The perhaps unusual name is the TeX name for the circled plus glyph. It would be nice if there was a semigroup class in the Haskell Base libraries...

Methods

oplus :: t -> t -> t

Instances

OPlus ()

OPlus (Primitive u)

Ord u => OPlus (BoundingBox u)

OPlus (UNil u)

OPlus a => OPlus (CF a)

OPlus (PrimGraphic u)

OPlus a => OPlus (r -> a)

(OPlus a, OPlus b) => OPlus (a, b)

OPlus a => OPlus (CF1 r1 a)

OPlus a => OPlus (CF2 r1 r2 a)

oconcat :: OPlus t => t -> [t] -> t

A bifunctor class

class Bimap f where

A Bifunctor class.

Again, it would be nice if there was a Bifunctor class in the Haskell Base libraries...

Methods

bimap :: (a -> p) -> (b -> q) -> f a b -> f p q

bimapL :: (a -> p) -> f a b -> f p b

bimapR :: (b -> q) -> f a b -> f a q

Instances

Bimap Either

Bimap (,)

replaceL :: Bimap f => p -> f a b -> f p b

replaceR :: Bimap f => q -> f a b -> f a q

Alignment

data HAlign

Horizontal alignment - align to the top, center or bottom.

Constructors

HTop

HCenter

HBottom

Instances

Enum HAlign

Eq HAlign

Ord HAlign

Show HAlign

data VAlign

Vertical alignment - align to the left, center or bottom.

Constructors

VLeft

VCenter

VRight

Instances

Enum VAlign

Eq VAlign

Ord VAlign

Show VAlign

Advance vector

type AdvanceVec u = Vec2 u

Advance vectors provide an idiom for drawing consecutive graphics. PostScript uses them to draw left-to-right text - each character has an advance vector for the width and as characters are drawn they successively displace the start point for the next character with their advance vector.

Type alias for Vec2.

advanceH :: AdvanceVec u -> u

Extract the horizontal component of an advance vector.

For left-to-right latin text, the vertical component of an advance vector is expected to be 0. Ingoring it seems permissible when drawing text.

advanceV :: AdvanceVec u -> u

Extract the verticall component of an advance vector.

Moving points

type PointDisplace u = Point2 u -> Point2 u

PointDisplace is a type representing functions from Point to Point.

It is especially useful for building composite graphics where one part of the graphic is drawn from a different start point to the other part.

displace :: Num u => u -> u -> PointDisplace u

displace : x -> y -> PointDisplace

Build a combinator to move Points by the supplied x and y distances.

displaceVec :: Num u => Vec2 u -> PointDisplace u

displaceV : (V2 x y) -> PointDisplace

Version of displace where the displacement is supplied as a vector rather than two parameters.

displaceH :: Num u => u -> PointDisplace u

displaceH : x -> PointDisplace

Build a combinator to move Points by horizontally the supplied x distance.

displaceV :: Num u => u -> PointDisplace u

displaceV : y -> PointDisplace

Build a combinator to move Points vertically by the supplied y distance.

type ThetaPointDisplace u = Radian -> PointDisplace u

ThetaPointDisplace is a type representing functions from Radian * Point to Point.

It is useful for building arrowheads which are constructed with an implicit angle representing the direction of the line at the arrow tip.

displaceParallel :: Floating u => u -> ThetaPointDisplace u

displaceParallel : dist -> ThetaPointDisplace

Build a combinator to move Points in parallel to the direction of the implicit angle by the supplied distance dist.

displacePerpendicular :: Floating u => u -> ThetaPointDisplace u

displaceParallel : dist -> ThetaPointDisplace

Build a combinator to move Points perpendicular to the direction of the implicit angle by the supplied distance dist.

Monadic drawing

type family MonUnit m :: *

DUnit is always for fully saturated type constructors, so (seemingly) an equivalent type family is needed for monads.

class Monad m => PointSupplyM m where

A monad that supplies points, e.g. a turtle monad.

** WARNING ** - the idea behind this class is somewhat half-baked. It may be revised or even dropped in subsequent versions of Wumpus-Basic.

Methods

position :: MonUnit m ~ u => m (Point2 u)