
Data.Generics.Fixplate.Open 




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


Synopsis 

toList :: Foldable t => t a > [a]   toRevList :: Foldable f => f a > [a]   mapAccumL :: Traversable t => (a > b > (a, c)) > a > t b > (a, t c)   mapAccumR :: Traversable t => (a > b > (a, c)) > a > t b > (a, t c)   mapAccumL_ :: Traversable f => (a > b > (a, c)) > a > f b > f c   mapAccumR_ :: Traversable f => (a > b > (a, c)) > a > f b > f c   holes :: Traversable f => f a > f (a, a > f a)   holesList :: Traversable f => f a > [(a, a > f a)]   apply :: Traversable f => (a > a) > f a > f (f a)   builder :: Traversable f => f a > [b] > f b   project :: Foldable f => Int > f a > Maybe a   unsafeProject :: Foldable f => Int > f a > a   sizeF :: Foldable f => f a > Int   enumerate :: Traversable f => f a > (Int, f (Int, a))   enumerateWith :: Traversable f => (Int > a > b) > f a > (Int, f b)   enumerateWith_ :: Traversable f => (Int > a > b) > f a > f b   data Hole = Hole   data Shape f   shape :: Functor f => f a > Shape f   zipF :: (Traversable f, EqF f) => f a > f b > Maybe (f (a, b))   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)   unsafeZipWithF :: Traversable f => (a > b > c) > f a > f b > f c   zipWithFM :: (Traversable f, EqF f, Monad m) => (a > b > m c) > f a > f b > m (Maybe (f c))   unsafeZipWithFM :: (Traversable f, Monad m) => (a > b > m c) > f a > f b > m (f c) 


Documentation 


List of elements of a structure.



Equivalent to reverse . toList.


Accumulating maps



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.



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.






Open functions



The children together with functions replacing that particular child.





Apply the given function to each child in turn.



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



Extracts the ith child.





Number of children. This is the generalization of length to foldable functors:
sizeF x = length (toList x)


Enumerations



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.






Shapes



This a data type defined to be a placeholder 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   Instances  



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  



Extracting the "shape" of the functor


Zips



Zips two structures if they are compatible.





Zipping two structures using a function.



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



Monadic version of zipWithF. TODO: better name?




Produced by Haddock version 2.6.1 