Data.Generics.Fixplate.Open

"Open" functions, working on functors instead of trees.

Documentation

toList :: Foldable t => forall a. t a -> [a]

List of elements of a structure, from left to right.

toRevList :: Foldable f => f a -> [a]

Equivalent to reverse . toList.

Accumulating maps

mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)

The mapAccumL function behaves like a combination of fmap and foldl; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.

mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)

The mapAccumR function behaves like a combination of fmap and foldr; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure.

mapAccumL_ :: Traversable f => (a -> b -> (a, c)) -> a -> f b -> f c

mapAccumR_ :: Traversable f => (a -> b -> (a, c)) -> a -> f b -> f c

Open functions

holes :: Traversable f => f a -> f (a, a -> f a)

The children together with functions replacing that particular child.

holesList :: Traversable f => f a -> [(a, a -> f a)]

apply :: Traversable f => (a -> a) -> f a -> f (f a)

Apply the given function to each child in turn.

builder :: Traversable f => f a -> [b] -> f b

Builds up a structure from a list of the children. It is unsafe in the sense that it will throw an exception if there are not enough elements in the list.

Individual elements

project :: Foldable f => Int -> f a -> Maybe a

Extracts the ith child.

unsafeProject :: Foldable f => Int -> f a -> a

sizeF :: Foldable f => f a -> Int

Number of children. This is the generalization of length to foldable functors:

sizeF x = length (toList x)

Enumerations

enumerate :: Traversable f => f a -> (Int, f (Int, a))

Enumerates children from the left to the right, starting with zero. Also returns the number of children. This is just a simple application of mapAccumL.

enumerateWith :: Traversable f => (Int -> a -> b) -> f a -> (Int, f b)

enumerateWith_ :: Traversable f => (Int -> a -> b) -> f a -> f b

Shapes

data Hole

This a data type defined to be a place-holder for childs. It is used in tree drawing, hashing, and Shape.

It is deliberately not made an instance of Show, so that you can choose your preferred style. For example, an acceptable choice is

instance Show Hole where show _ = "_"

Constructors

Hole

Instances

Eq Hole

Methods

(==) :: Hole -> Hole -> Bool

(/=) :: Hole -> Hole -> Bool

Ord Hole

Methods

compare :: Hole -> Hole -> Ordering

(<) :: Hole -> Hole -> Bool

(<=) :: Hole -> Hole -> Bool

(>) :: Hole -> Hole -> Bool

(>=) :: Hole -> Hole -> Bool

max :: Hole -> Hole -> Hole

min :: Hole -> Hole -> Hole

data Shape f

A type encoding the "shape" of the functor data: We ignore all the fields whose type is the parameter type, but remember the rest:

newtype Shape f = Shape { unShape :: f Hole }

This can be used to decide whether two realizations are compatible.

Instances

EqF f => Eq (Shape f)

Methods

(==) :: Shape f -> Shape f -> Bool

(/=) :: Shape f -> Shape f -> Bool

OrdF f => Ord (Shape f)

Methods

compare :: Shape f -> Shape f -> Ordering

(<) :: Shape f -> Shape f -> Bool

(<=) :: Shape f -> Shape f -> Bool

(>) :: Shape f -> Shape f -> Bool

(>=) :: Shape f -> Shape f -> Bool

max :: Shape f -> Shape f -> Shape f

min :: Shape f -> Shape f -> Shape f

(Functor f, ShowF f) => Show (Shape f)

Methods

showsPrec :: Int -> Shape f -> ShowS

show :: Shape f -> String

showList :: [Shape f] -> ShowS

shape :: Functor f => f a -> Shape f

Extracting the "shape" of the functor

Zips

zipF :: (Traversable f, EqF f) => f a -> f b -> Maybe (f (a, b))

Zips two structures if they are compatible.

unzipF :: Functor f => f (a, b) -> (f a, f b)

zipWithF :: (Traversable f, EqF f) => (a -> b -> c) -> f a -> f b -> Maybe (f c)

Zipping two structures using a function.

unsafeZipWithF :: Traversable f => (a -> b -> c) -> f a -> f b -> f c

Unsafe version of zipWithF: does not check if the two structures are compatible. It is left-biased in the sense that the structure of the second argument is retained.

zipWithFM :: (Traversable f, EqF f, Monad m) => (a -> b -> m c) -> f a -> f b -> m (Maybe (f c))

Monadic version of zipWithF. TODO: better name?

unsafeZipWithFM :: (Traversable f, Monad m) => (a -> b -> m c) -> f a -> f b -> m (f c)