!>]      !"# $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!!!!!!!!""""""""""######$$$$$$$%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&''''''''''''''''((((( ( ( ( ) )))))))******++++++ +!+"+#+$+%,&,',(,),*,+,,---../.0/1/2030415162728292:2;2<2=2>3?3@3A3B3C3D4E4F4G4H4I5J6K6L6M6N6O6P6Q6R6S6T6U7V7W7X7Y7Z7[7\7]7^7_7`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q9r9s:t:u:v:w:x:y:z:{:|:}:~:::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;<<==========>>>>>>>>>>>>>>?????@@@@@@@@@@@@@@@@@@@@AAAAABBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDD D D D D DEFFFFFFFFFFFFFFFGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G2G3G4H5H6H7H8H9H:H;H<H=H>H?H@HAHBHCIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[J\JUSafe&',-.=>?@AEHRSUVWXkq"YpandoraAlgebra's type operatorpandoraCoalgebra's type operatorpandoraFlipped functors compositionpandoraFunctors compositionpandoraParameter application   22200110Safe&',-.=>?@AEHRSUVWXkq$G   8129 Safe&',-.=>?@AEHRSUVWXkq%Safe&',-.=>?@AEHRSUVWXkq&Safe&',-.=>?@AEHRSUVWXkq'Safe&',-.=>?@AEHRSUVWXkq(Safe&',-.=>?@AEHRSUVWXkq* Safe&',-.=>?@AEHRSUVWXkq+ ! ! Safe&',-.=>?@AEHRSUVWXkq,%#$#$KSafe&',-.=>?@AEHRSUVWXkq-3  !#$ Safe&',-.=>?@AEHRSUVWXkq7 &pandora When providing a new instance, you should ensure it satisfies the two laws: * Identity morphism: contramap identity "a identity * Interpreted of morphisms: contramap f . contramap g "a contramap (g . f)'pandoraInfix version of ((pandoraPrefix version of ')pandora7Replace all locations in the output with the same value*pandoraFlipped version of )+pandoraFill the input of evaluation,pandoraFlipped infix version of (-pandoraInfix versions of ( with various nesting levels0pandoraInfix flipped versions of ( with various nesting levels &'*)(+,-./012 &'*)(+,-./012'4)4*4 Safe&',-.=>?@AEHRSUVWXkqB 3pandora When providing a new instance, you should ensure it satisfies the two laws: * Identity morphism: comap identity "a identity * Interpreted of morphisms: comap (f . g) "a comap f . comap g4pandoraInfix version of 55pandoraPrefix version of 46pandora6Replace all locations in the input with the same value7pandoraFlipped version of 68pandora!Discards the result of evaluation9pandora,Computing a value from a structure of values:pandoraFlipped infix version of 5;pandoraInfix versions of 5 with various nesting levels>pandoraInfix flipped versions of 5 with various nesting levels34;56789:<=>?@34;56789:<=>?@446474 Safe&',-.=>?@AEHRSUVWXkqJ~Bpandora rWhen providing a new instance, you should ensure it satisfies the one law: * Interchange: t >>= f = join (f <$> t)CpandoraInfix and flipped version of E, the dual of =>>DpandoraFlipped version of C, the dual of <<=EpandoraPrefix and flipped version of C, the dual of extendFpandora$Merge effects/contexts, the dual of  duplicateGpandora!Left-to-right Kleisli compositionHpandora!Right-to-left Kleisli compositionBCFDHGEBCFDHGEC1D1G1H1 Safe&',-.=>?@AEHRSUVWXkqTJpandora When providing a new instance, you should ensure it satisfies the three laws: * Interpreted: (.) <$> u <*> v <*> w "a u <*> (v <*> w) * Left interchange: x <*> (f <$> y) "a (. f) <$> x <*> y * Right interchange: f <$> (x <*> y) "a (f .) <$> x <*> yKpandoraInfix version of LLpandoraPrefix version of KMpandora<Sequence actions, discarding the value of the first argumentNpandora=Sequence actions, discarding the value of the second argumentOpandoraRepeat an action indefinitelyPpandoraInfix versions of L with various nesting levels JKLOMPNQR JKLOMPNQRK4M4N4Safe&',-.=>?@AEHRSUVWXkqZXTpandora When providing a new instance, you should ensure it satisfies the two laws: * Associativity of <+>: (x <+> y) <+> z "a x <+> (y <+> z) * Left-distributes <$> over <+>: f <$> (x <+> y) "a (f <$> x) <+> (f <$> y)UpandoraInfix version of VVpandoraPrefix version of UTUVTUVU3Safe&',-.=>?@AEHRSUVWXkq]Wpandora When providing a new instance, you should ensure it satisfies the two laws: * Left absorption: x <+> empty "a x * Right absorption: empty <+> x "a xWXWXSafe&',-.=>?@AEHRSUVWXkqfYpandora When providing a new instance, you should ensure it satisfies the four laws: * Left adjunction identity: phi cozero "a identity * Right adjunction identity: psi zero "a identity * Left adjunction interchange: phi f "a comap f . eta * Right adjunction interchange: psi f "a epsilon . comap fZpandoraLeft adjunction[pandoraRight adjunction\pandoraPrefix and flipped version of `]pandoraPrefix and flipped version of [^pandoraAlso known as unit_pandoraAlso known as counitYZ[^\]_`YZ[^\]_`Z4[4`4Safe&',-.=>?@AEHRSUVWXkqhabbaa0LSafe&',-.=>?@AEHRSUVWXkqi3 abSafe&',-.=>?@AEHRSUVWXkqj}cdcdSafe&',-.=>?@AEHRSUVWXkqqepandora %Let f :: Distributive g => (a -> g b) When providing a new instance, you should ensure it satisfies the two laws: * Identity morphism: distribute . distribute "a identity * Interchange collection: collect f "a distribute . comap ffpandoraInfix and flipped version of ggpandoraPrefix version of fhpandora The dual of sequenceipandoraInfix versions of g with various nesting levelsefhijkgefhijkgf5i5j5k5Safe&',-.=>?@AEHRSUVWXkqw0mpandora When providing a new instance, you should ensure it satisfies the two laws: * Identity: dimap identity identity "a identity * Interpreted: dimap (f . g) (h . i) "a dimap g h . dimap f inpandoraInfix version of comapopandoraPrefix version of nmpnompnon4p0Safe&',-.=>?@AEHRSUVWXkqxtrstuvwuvwrstSafe&',-.=>?@AEHRSUVWXkqzpandora When providing a new instance, you should ensure it satisfies the three laws: * Duplication interchange: comap (comap f) . duplicate "a duplicate . comap f * Extension interchange: extend f "a comap f . duplicate{pandoraInfix and flipped version of }, the dual of >>=|pandoraFlipped version of >>=, the dual of =<<}pandoraPrefix and flipped version of {, the dual of bind~pandora&Clone existing structure, the dual of joinpandora#Right-to-left Cokleisli compositionpandora#Left-to-right Cokleisli compositionz{}|~z{}|~{1|111Safe&',-.=>?@AEHRSUVWXkqsSafe&',-.=>?@AEHRSUVWXkqpandora ]Let f :: (Pointable t, Bindable t) => t a -> b Let g :: (Pointable t, Bindable t) => t a -> b When providing a new instance, you should ensure it satisfies the three laws: * Left identity: extend extract "a identity * Right identity: extract . extend f "a f * Associativity: extend f . extend g "a extend (f . extend g)Safe&',-.=>?@AEHRSUVWXkqpandora When providing a new instance, you should ensure it satisfies the two laws: Identity morphisms: invmap identity identity = identity Interpreted of morphisms: invmap g j . invmap f h = invmap (g . f) (h . j)Safe&',-.=>?@AEHRSUVWXkq Safe&',-.=>?@AEHRSUVWXkqSafe&',-.=>?@AEHRSUVWXkq%Safe&',-.=>?@AEHRSUVWXkqpandora Let f :: (Pointable t, Bindable t) => a -> t a Let g :: (Pointable t, Bindable t) => a -> t a Let h :: (Pointable t, Bindable t) => t a When providing a new instance, you should ensure it satisfies the three laws: * Left identity: point a >>= f "a f a * Right identity: h >>= point "a h * Associativity: h >>= (\x -> f x >>= g) "a (h >>= f) >>= gSafe&',-.=>?@AEHRSUVWXkqSafe&',-.=>?@AEHRSUVWXkq Safe&',-.=>?@AEHRSUVWXkq\pandoraCall with current continuationpandora Delimit the continuation of any pandora5Capture the continuation up to the nearest enclosing  and pass it!Safe&',-.=>?@AEHRSUVWXkqpandora!Take incoming value from pipelinepandora$Give a value to the future consumingpandoraPipeline that does nothingpandora-Do some effectful computation within pipelinepandoraCompose two pipelines into onepandoraRun pipeline and get result"Safe&',-.=>?@AEHRSUVWXkq pandoraMake continuation observablepandora,Listen only first event, call back just oncepandoraInfix version of pandora*Listen only first event, call back foreverpandoraInfix version of pandora2Listen all events from action, call back just oncepandoraInfix version of pandora0Listen all events from action, call back foreverpandoraInfix version of  MSafe&',-.=>?@AEHRSUVWXkq#Safe&',-.=>?@AEHRSUVWXkqpandora When providing a new instance, you should ensure it satisfies the three laws: * Isomorphism (to): tabulate . index "a identity * Isomorphism (from): index . tabulate "a identity * Right adjoint: tabulate . point "a point * Interchange tabulation: comap f . tabulate "a tabulate . comap fpandoraInfix and flipped version of pandoraPrefix and flipped version of $Safe&',-.=>?@AEHRSUVWXkqpandora gLet f :: (Applicative t, Applicative g) => t a -> u a Let p :: (Pointable t, Pointable g) => t a -> u a  When providing a new instance, you should ensure it satisfies the four laws: * Naturality of traversing: g . traverse f "a traverse (g . f) * Naturality of sequencing: f . sequence = sequence . comap f * Preserving point: p (point x) "a point x * Preserving apply: f (x <*> y) "a f x <*> f ypandoraInfix version of pandoraPrefix version of pandora The dual of  distributepandoraInfix versions of  with various nesting levels5555NSafe&',-.=>?@AEHRSUVWXkq/d&'*)(+,-./01234;56789:<=>?@BCFDHGEJKLOMPNQRTUVWXYZ[^\]_`cdefhijkgmpnoz{}|~%Safe&',-.=>?@AEHRSUVWXkq3&Safe&',-.=>?@AEHRSUVWXkq'Safe&',-.=>?@AEHRSUVWXkqOSafe&',-.=>?@AEHRSUVWXkq2 !#$(Safe&',-.=>?@AEHRSUVWXkqĈ  )Safe&',-.=>?@AEHRSUVWXkqŶ    *Safe&',-.=>?@AEHRSUVWXkq6+Safe&',-.=>?@AEHRSUVWXkq,Safe&',-.=>?@AEHRSUVWXkq%&(')%&(')-Safe&',-.=>?@AEHRSUVWXkq3,pandora uWhen providing a new instance, you should ensure it satisfies the one law: * Associativity: x + (y + z) "a (x + y) + z,-,-.Safe&',-.=>?@AEHRSUVWXkq/.pandora When providing a new instance, you should ensure it satisfies the two laws: * Left distributivity: x * (y + z) "a x * y + x * z * Right distributivity: (y + z) * x "a y * x + z * x././/Safe&',-.=>?@AEHRSUVWXkqӓ0pandora When providing a new instance, you should ensure it satisfies the two laws: * Right absorption: zero + x "a x * Left absorption: x + zero "a x01010Safe&',-.=>?@AEHRSUVWXkq32pandora When providing a new instance, you should ensure it satisfies the one law: * Additive identity is a multiplicative annihilator: zero * x = x  * zero = zero23231Safe&',-.=>?@AEHRSUVWXkq4pandora When providing a new instance, you should ensure it satisfies the two laws: * Right absorption: x + inverse x "a zero * Left absorption: inverse x + x "a zero45452Safe&',-.=>?@AEHRSUVWXkq6786783Safe&',-.=>?@AEHRSUVWXkq>?@>?@4Safe&',-.=>?@AEHRSUVWXkqEpandora When providing a new instance, you should ensure it satisfies the three laws: * Associativity: x \/ (y \/ z) "a (x \/ y) \/ z * Commutativity: x \/ y "a y \/ x * Idempotency: x \/ x "a xGpandora When providing a new instance, you should ensure it satisfies the three laws: * Associativity: x /\ (y /\ z) "a (x /\ y) /\ z * Commutativity: x /\ y "a y /\ x * Idempotency: x /\ x "a xDEFGHGHEFD5Safe&',-.=>?@AEHRSUVWXkqIIpandora zWhen providing a new instance, you should ensure it satisfies the one law: * Absorption: a \/ (a /\ b) "a a /\ (a \/ b) "a aII6Safe&',-.=>?@AEHRSUVWXkqJpandora When providing a new instance, you should ensure it satisfies the four laws: * Reflexivity: x == x "a True * Symmetry: x == y "a y == x * Transitivity: x == y && y == z "a True ===> x == z "a True * Negation: x /= y "a not (x == y) JKLMONPQRST MONPQTRSJKLK4L4P3Q T17Safe&',-.=>?@AEHRSUVWXkqSUpandora When providing a new instance, you should ensure it satisfies the three laws: * Reflexivity: x <= x "a True * Transitivity: x <= y && y <= z "a True ===> x <= z "a True * Antisymmetry: x <= y && y <= x "a True ===> x == y "a True UVZWXY[\^]_ [\^]_UVZWXYPSafe&',-.=>?@AEHRSUVWXkq&,-./012345DEFGHIJKLMONPQRSTUVZWXY[\^]_QSafe&',-.=>?@AEHRSUVWXkq? !#$&'*)(+,-./01234;56789:<=>?@BCFDHGEJKLOMPNQRTUVWXYZ[^\]_`cdefhijkgmpnoz{}|~,-./012345DEFGHIJKLMONPQRSTUVZWXY[\^]_8Safe&',-.=>?@AEHRSUVWXkq`abcd`abcda59Safe&',-.=>?@AEHRSUVWXkqqrqr:Safe&',-.=>?@AEHRSUVWXkqstuvwtuvwss0;Safe&',-.=>?@AEHRSUVWXkq=  11<Safe&',-.=>?@AEHRSUVWXkq=Safe&',-.=>?@AEHRSUVWXkq>Safe&',-.=>?@AEHRSUVWXkq?Safe&',-.=>?@AEHRSUVWXkq @Safe&',-.=>?@AEHRSUVWXkq!ASafe&',-.=>?@AEHRSUVWXkq7pandora%Acyclic graph structure without loopspandora>Transform any traversable structure into all loose edges graphBSafe&',-.=>?@AEHRSUVWXkqpandoraLens composition infix operatorpandoraGet the target of a lenspandoraInfix version of pandoraReplace the target of a lenspandoraInfix version of pandoraModify the target of a lenspandoraInfix version of   0RSafe&',-.=>?@AEHRSUVWXkq >CSafe&',-.=>?@AEHRSUVWXkq DSafe&',-.=>?@AEHRSUVWXkqpandora=Linear data structure that serves as a collection of elementspandora0Transform any traversable structure into a stackSSafe&',-.=>?@AEHRSUVWXkq qrESafe&',-.=>?@AEHRSUVWXkq<pandora7Type synonymous for at least one element data structureTSafe&',-.=>?@AEHRSUVWXkqB qrFSafe&',-.=>?@AEHRSUVWXkqlGSafe&',-.=>?@AEHRSUVWXkqHSafe&',-.=>?@AEHRSUVWXkq4545ISafe&',-.=>?@AEHRSUVWXkqCDEFGHIDEFCGHIJSafe&',-.=>?@AEHRSUVWXkqW   %&(')678>?@`abcdstuvw45CDEFGHI[\[\USafe&',-.=>?@AEHRSUVWXkq>   %&(')678>?@`abcdqrstuvw45CDEFGHI[\]VWXYZ[\]^_`abcdefgghijkllmnnoppqrrs t t u v w x y z { | } ~        !!!!!!!!!""""""" " " " # #####$$$$$$$%%%%%%% %!%"%#%$%%%&%'%(%)%*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&='>'?'?'@'A'B'C'D'E'F'G'H'I'J'K'L(M(N(O(P(Q(R(S(T)U)V)W)X)Y)Z)[)\*]*^*_*`*a*b+c+d+e+f+g+h+i+j+k+l+m,n,o,p,q,r,s,t-u-v.w.x/y/z0{0|1}1~2222222233333344444566666666666777777777778888888888888888899::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;<<==========>>>>>>>>>>>>>>?????@@@@@ @ @ @ @ @@@@@@@@@@@AAAAABBB B!B"B#B$B%B&B'C(C)C*C+C,C-C.CCCCC/C0C1C2C3C4C5C6C7C8C9C:C;C<C=C>C?D@DADBDCDDDEDFDGDHDIDJDKDLEMFNFOFPFQFRFSFTFUFVFWFXFYFZF[F\G]G]G^G_G`GaGbGcGdGeGfGgGhGiGjGkGlGmGnGoGpGqHrHrHsHtHuHvHwHxHyHzH{H|H}H~HIIIIIIII.IIIIIIIIIIIIIIIIJJ$pandora-0.2.2-9KVvPXx7JR98shUTBea58ZPandora.Core.FunctorPandora.Core.MorphismPandora.Paradigm.Basis.Fix.Pandora.Paradigm.Controlflow.Joint.Interpreted-Pandora.Paradigm.Controlflow.Joint.Schemes.TU.Pandora.Paradigm.Controlflow.Joint.Schemes.TUV/Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW-Pandora.Paradigm.Controlflow.Joint.Schemes.UT.Pandora.Paradigm.Controlflow.Joint.Schemes.UTU%Pandora.Pattern.Functor.Contravariant!Pandora.Pattern.Functor.Covariant Pandora.Pattern.Functor.Bindable#Pandora.Pattern.Functor.Applicative#Pandora.Pattern.Functor.Alternative!Pandora.Pattern.Functor.AvoidablePandora.Pattern.Functor.AdjointPandora.Core.Transformation$Pandora.Pattern.Functor.Determinable$Pandora.Pattern.Functor.Distributive!Pandora.Pattern.Functor.DivariantPandora.Paradigm.Basis.Kan"Pandora.Pattern.Functor.Extendable#Pandora.Pattern.Functor.ExtractablePandora.Pattern.Functor.Comonad!Pandora.Pattern.Functor.Invariant Pandora.Pattern.Functor.Liftable!Pandora.Pattern.Functor.Lowerable!Pandora.Pattern.Functor.PointablePandora.Pattern.Functor.MonadPandora.Paradigm.Basis.YonedaPandora.Paradigm.Basis.Proxy#Pandora.Paradigm.Basis.Continuation%Pandora.Paradigm.Controlflow.Pipeline'Pandora.Paradigm.Controlflow.Observable%Pandora.Pattern.Functor.Representable#Pandora.Pattern.Functor.Traversable.Pandora.Paradigm.Controlflow.Joint.Transformer,Pandora.Paradigm.Controlflow.Joint.Adaptable&Pandora.Paradigm.Inventory.EnvironmentPandora.Paradigm.Basis.Wye Pandora.Paradigm.Basis.VariationPandora.Paradigm.Basis.JetPandora.Paradigm.Basis.FreePandora.Paradigm.Basis.Edges Pandora.Pattern.Object.SemigroupPandora.Pattern.Object.RingoidPandora.Pattern.Object.Monoid Pandora.Pattern.Object.QuasiringPandora.Pattern.Object.Group!Pandora.Paradigm.Basis.ValidationPandora.Paradigm.Basis.Endo"Pandora.Pattern.Object.SemilatticePandora.Pattern.Object.LatticePandora.Pattern.Object.SetoidPandora.Pattern.Object.ChainPandora.Paradigm.Basis.Twister*Pandora.Paradigm.Structure.Specific.BinaryPandora.Paradigm.Basis.TaggedPandora.Paradigm.Basis.Product$Pandora.Paradigm.Structure.Cartesian"Pandora.Paradigm.Inventory.Storage&Pandora.Paradigm.Inventory.Accumulator Pandora.Paradigm.Basis.Predicate Pandora.Paradigm.Inventory.State)Pandora.Paradigm.Structure.Specific.Graph!Pandora.Paradigm.Inventory.OpticsPandora.Paradigm.Basis.Maybe)Pandora.Paradigm.Structure.Specific.Stack#Pandora.Paradigm.Structure.NonemptyPandora.Paradigm.Basis.JackPandora.Paradigm.Basis.IdentityPandora.Paradigm.Basis.Constant!Pandora.Paradigm.Basis.ConclusionPandora.Paradigm.Basis*Pandora.Paradigm.Controlflow.Joint.Schemes Pandora.CorePandora.Paradigm.ControlflowPandora.Pattern.Functor"Pandora.Paradigm.Controlflow.JointPandora.Pattern.ObjectPandora.PatternPandora.Paradigm.Inventory#Pandora.Paradigm.Structure.SpecificPandora.Paradigm.StructurePandora.Paradigm::|::::|.:::|:.<-||->.::.:=VariantCoContraidentityfix.&!%Fixunfix InterpretedPrimaryunwrapTU$fInterpretedTUTUV$fInterpretedTUVTUVW$fInterpretedTUVWUT$fInterpretedUTUTU$fInterpretedUTU Contravariant>$< contramap>$$<full>&<>$$<>$$$<>$$$$<>&&<>&&&<>&&&&< Covariant<$>comap<$$>voidloeb<&><$$><$$$><$$$$><&&><&&&><&&&&> $fCovariant->Bindable>>==<<bindjoin>=><=< $fBindable-> Applicative<*>apply*><*forever<**><***><****>$fApplicative-> Alternative<+>alter AvoidableemptyAdjoint-||-phipsietaepsilon~>Natural Determinable determine Distributive>>-collect distribute>>>->>>>->>>>>-$fDistributive-> Divariant>->dimap$ $fDivariant->RanranLanlan$fContravariantLan$fCovariantRan Extendable=>><<=extend duplicate=<==>= ExtractableextractComonad InvariantinvmapLiftablelift Lowerablelower Pointablepoint $fPointable->MonadYonedayoneda$fAdjointYonedaYoneda$fLiftableYoneda$fExtractableYoneda$fPointableYoneda$fAvoidableYoneda$fApplicativeYoneda$fAlternativeYoneda$fCovariantYonedaProxy$fExtendableProxy $fMonadProxy$fBindableProxy$fDistributiveProxy$fAlternativeProxy$fApplicativeProxy$fPointableProxy$fContravariantProxy$fCovariantProxy Continuationcontinuecwccresetshift$fLiftableContinuation$fMonadContinuation$fBindableContinuation$fApplicativeContinuation$fPointableContinuation$fCovariantContinuationPipelineawaityieldfinishimpact=*=pipeline$fContravariantPipe$fCovariantPipe Observableobservenotify.:~.follow.:~* subscribe*:~.watch*:~* RepresentableRepresentation<#>tabulateindex$fRepresentable-> Traversable->>traversesequence->>>->>>>->>>>>:>Ttrans TransformerSchemalaywrap$fInterpreted:>$fExtendable:> $fBindable:>$fDistributive:>$fTraversable:>$fAlternative:>$fApplicative:>$fExtractable:> $fPointable:> $fCovariant:> Adaptableadapt $fAdaptablett$fAdaptableh:>$fAdaptablef:>$fAdaptablez:>$fAdaptabley:>$fAdaptablex:>$fAdaptablew:>$fAdaptablev:>$fAdaptableu:>$fAdaptablef:>0$fAdaptablez:>0$fAdaptabley:>0$fAdaptablex:>0$fAdaptablew:>0$fAdaptablev:>0$fAdaptableu:>0$fAdaptablet:> Configured Environmentenv $fBindableTU$fApplicativeTU $fPointableTU $fCovariantTU$fTransformerEnvironment$fInterpretedEnvironment$fMonadEnvironment$fBindableEnvironment$fDistributiveEnvironment$fApplicativeEnvironment$fPointableEnvironment$fCovariantEnvironmentWyeEndLeftRightBothwye$fTraversableWye$fCovariantWye VariationThisThatThese variation$fTraversableVariation$fPointableVariation$fCovariantVariationJet:-$fExtractableJet$fPointableJet$fTraversableJet$fCovariantJetFreePureImpure$fLiftableFree$fTraversableFree$fBindableFree$fApplicativeFree$fAvoidableFree$fAlternativeFree$fPointableFree$fCovariantFreeEdgesEmptyConnectOverlayedges$fTraversableEdges$fCovariantEdges Semigroup+Ringoid*Monoidzero QuasiringoneGroupinverse ValidationFlaws Validated$fTraversableValidation$fAlternativeValidation$fApplicativeValidation$fPointableValidation$fCovariantValidationEndoendo $fMonoidEndo$fSemigroupEndo$fInvariantEndo SemilatticeSupremum\/Infimum/\LatticeSetoid==/=BooleanTrueFalse&&||notbool?Chain<=><<=>>=OrderingLessEqualGreaterorderTwister:<untwist coiteratesection$fMonoidTwister$fSemigroupTwister$fSetoidTwister$fComonadTwister$fMonadTwister$fExtendableTwister$fBindableTwister$fTraversableTwister$fApplicativeTwister$fExtractableTwister$fPointableTwister$fCovariantTwisterBinaryinsert:#TaggedTagretagtagself $fGroupTagged$fLatticeTagged$fSupremumTagged$fInfimumTagged$fRingoidTagged$fMonoidTagged$fSemigroupTagged $fChainTagged$fSetoidTagged$fComonadTagged$fExtendableTagged $fMonadTagged$fBindableTagged$fDistributiveTagged$fTraversableTagged$fApplicativeTagged$fExtractableTagged$fPointableTagged$fCovariantTagged InjectiveHas:*:Productdeltaswapattachedcurryuncurry$fGroupProduct$fLatticeProduct$fSupremumProduct$fInfimumProduct$fRingoidProduct$fMonoidProduct$fSemigroupProduct$fSetoidProduct$fAdjointProduct->$fComonadProduct$fExtendableProduct$fTraversableProduct$fExtractableProduct$fCovariantProduct Cartesian-:*:-Storagestoredpositionaccessretrofit$fComonadStorage$fExtendableStorage$fExtractableStorage$fCovariantStorage Accumulated Accumulatorgather $fBindableUT $fPointableUT$fApplicativeUT $fCovariantUT$fTransformerAccumulator$fInterpretedAccumulator$fBindableAccumulator$fPointableAccumulator$fApplicativeAccumulator$fCovariantAccumulator Predicate predicate$fDeterminablePredicate$fContravariantPredicateStatefulStatefoldfindcurrentmodifyreplace $fMonadTUV $fBindableTUV$fPointableTUV$fApplicativeTUV$fCovariantTUV$fTransformerState$fInterpretedState $fMonadState$fBindableState$fPointableState$fApplicativeState$fCovariantStateGraphloose$fInterpretedGraph$fTraversableGraph$fCovariantGraphLens:-.|>view^.set.~over%~$fAdjointStorageStateOptionalMaybeNothingJustmaybenothing $fMonadUT$fTransformerMaybe$fInterpretedMaybe$fLatticeMaybe$fSupremumMaybe$fInfimumMaybe $fMonoidMaybe$fSemigroupMaybe $fChainMaybe $fSetoidMaybe $fMonadMaybe$fBindableMaybe$fTraversableMaybe$fAlternativeMaybe$fApplicativeMaybe$fAvoidableMaybe$fPointableMaybe$fCovariantMaybeStackpushtoppopfilter linearize$fInterpretedStack$fTraversableStack$fApplicativeStack$fAvoidableStack$fAlternativeStack$fPointableStack$fCovariantStackNonemptyJackItOtherjack $fChainJack $fSetoidJack$fLiftableJack$fDistributiveJack$fTraversableJack$fApplicativeJack$fExtractableJack$fAvoidableJack$fAlternativeJack$fPointableJack$fCovariantJackIdentity$fGroupIdentity$fLatticeIdentity$fSupremumIdentity$fInfimumIdentity$fRingoidIdentity$fMonoidIdentity$fSemigroupIdentity$fChainIdentity$fSetoidIdentity$fAdjointIdentityIdentity$fComonadIdentity$fExtendableIdentity$fMonadIdentity$fBindableIdentity$fDistributiveIdentity$fTraversableIdentity$fApplicativeIdentity$fExtractableIdentity$fPointableIdentity$fCovariantIdentityConstant$fGroupConstant$fLatticeConstant$fSupremumConstant$fInfimumConstant$fRingoidConstant$fMonoidConstant$fSemigroupConstant$fChainConstant$fSetoidConstant$fTraversableConstant$fInvariantConstant$fContravariantConstant$fCovariantConstantFailable ConclusionFailureSuccess conclusionfailfailure$fTransformerConclusion$fInterpretedConclusion$fSemigroupConclusion$fChainConclusion$fSetoidConclusion$fMonadConclusion$fBindableConclusion$fTraversableConclusion$fAlternativeConclusion$fApplicativeConclusion$fPointableConclusion$fCovariantConclusionnotehush