úÎ/Û-±     Safe-Inferred-HJKMEHeterogenous 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.NoneJK)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-Inferred 234=HJKM 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.2Data.StackPrismData.StackPrism.THData.StackPrism.Generic:- StackPrism stackPrismforwardbackwardderiveStackPrismsderiveStackPrismsWithderiveStackPrismsFor PrismList StackPrisms mkPrismListderiveStackPrismsWith'deriveStackPrism-:deriveConstructorderiveDestructorconName MkStackPrismmkRmkL StackPrismLhs MkPrismList mkPrismList'P:&mapHead$fMkStackPrism:*:TFCo:R:StackPrismLhs:*:t$fMkStackPrismM1TFCo:R:StackPrismLhsM1t$fMkStackPrismK1TFCo:R:StackPrismLhsK1t$fMkStackPrismU1TFCo:R:StackPrismLhsU1t$fMkPrismListM1TFCo:R:PrismListM1a$fMkPrismList:+:TFCo:R:PrismList:+:a$fMkPrismListM10TFCo:R:PrismListM1a0