úÎ0-÷     Safe2OQRTEHeterogenous stack with a head and a tail. Or: an infix way to write (,).~A stack prism is a bidirectional isomorphism that is partial in the backward direction. These prisms are compatible with the lens library.FStack prisms can express constructor-deconstructor pairs. For example: ÿGnil :: StackPrism t ([a] :- t) nil = stackPrism f g where f t = [] :- t g ([] :- t) = Just t g _ = Nothing cons :: StackPrism (a :- [a] :- t) ([a] :- t) cons = stackPrism f g where f (x :- xs :- t) = (x : xs) :- t g ((x : xs) :- t) = Just (x :- xs :- t) g _ = NothingHere A can be read as 'cons', forming a stack of values. For example, nil pushes []A onto the stack; or, in the backward direction, tries to remove [] from the stack. cons takes a head x and tail xs from the stack and pushes x : xs? onto the stack, or, in the backward direction, tries to take x : xsD from the stack and replaces it with its two individual components.ªEvery constructor has its own stack prism version. You don't have to write them by hand; you can automatically generate them, either using Template Haskell (see module Data.StackPrism.TH0) or using GHC generic programming (see module Data.StackPrism.Generic).Construct a prism.#Apply a prism in forward direction.$Apply a prism in backward direction.55NoneQR[ )Derive stack prisms for a given datatype. For example: deriveStackPrisms ''Maybe will create S_Just :: StackPrism (a :- t) (Maybe a :- t) _Nothing :: StackPrism t (Nothing :- t)$together with their implementations. XDerive stack prisms given a function that derives variable names from constructor names. MDerive stack prisms given a list of variable names, one for each constructor.    Safe 9:;DOQRT UA data family that is indexed on the building blocks from representation types from  GHC.Generics‹. It builds up to a list of prisms, one for each constructor in the generic representation. The list is wrapped in the unary constructor  PrismListg. Within that constructor, the prisms are separated by the right-associative binary infix constructor :&G. Finally, the individual prisms are wrapped in the unary constructor P.0As an example, here is how to define the prisms nil and cons for [a], which is an instance of Generic: ˜nil :: StackPrism t ([a] :- t) cons :: StackPrism (a :- [a] :- t) ([a] :- t) PrismList (P nil :& P cons) = mkPrismList :: StackPrisms [a] Convenient shorthand for a  3 indexed by a type and its generic representation.GDerive a list of stack prisms. For more information on the shape of a  %, please see the documentation below. ! "#$%&'(  "#$   ! %&"'#($# )      !"#$%&'()*+(stack-prism-0.1.6-Hu1mvHuM3hWLTn0wIxGTPqData.StackPrismData.StackPrism.THData.StackPrism.Generic:- StackPrism stackPrismforwardbackward$fEq:-$fShow:- $fFunctor:-deriveStackPrismsderiveStackPrismsWithderiveStackPrismsFor PrismList StackPrisms mkPrismList$fMkStackPrism:*:$fMkStackPrismM1$fMkStackPrismK1$fMkStackPrismU1$fMkPrismListM1$fMkPrismList:+:$fMkPrismListM10deriveStackPrismsWith'deriveStackPrism-:deriveConstructorderiveDestructorconName MkStackPrismmkRmkL StackPrismLhs MkPrismList mkPrismList'P:&mapHeadD:R:PrismListM1a0D:R:PrismList:+:a0D:R:PrismListM1a2