!x'p      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoSafe .>HUVXkhaskus-utils-variant(Convert a data into a multi-continuationhaskus-utils-variant2Convert a data into a multi-continuation (monadic)haskus-utils-variant5Convert a tuple of continuations into a list of types haskus-utils-variantRConvert a list of types into the actual data type representing the continuations. haskus-utils-variant!A continuation based control-flow haskus-utils-variant'Bind a flow to a tuple of continuations haskus-utils-variant)Bind a flow to a 1-tuple of continuationshaskus-utils-variantHBind a flow to a tuple of continuations and reorder fields if necessary     0 00None%,.=>?@AEHISUVXgkmz=haskus-utils-variant+Convert a variant into a multi-continuationhaskus-utils-variant+Convert a variant into a multi-continuationhaskus-utils-variant+Convert a multi-continuation into a Varianthaskus-utils-variant+Convert a multi-continuation into a Varianthaskus-utils-variant(Convert a variant into a HList of Maybeshaskus-utils-variantJoin on a variantsTransform a variant of applicatives as follow: f :: V '[m a, m b, m c] -> m (V '[a,b,c]) f = joinVariant @mhaskus-utils-variantxs is liftable in ys haskus-utils-variantLUseful to specify a "* -> Constraint" function returning an empty constraint#haskus-utils-variant\A value of type "x" **might** be extracted from (V xs). We don't check that "x" is in "xs".$haskus-utils-variantForall x in xs , `x :< ys`%haskus-utils-variant0A value of type "x" can be extracted from (V xs)(haskus-utils-variantRemove a type from a variant)haskus-utils-variantPA variant contains a value whose type is at the given position in the type list+haskus-utils-variant*Statically unchecked matching on a Variant,haskus-utils-variant"Silent pattern synonym for Variant^Usage: case v of VSilent (x :: Int) -> ... VSilent (x :: String) -> ...-haskus-utils-variantPattern synonym for VariantRUsage: case v of V (x :: Int) -> ... V (x :: String) -> ....haskus-utils-variantGet Variant index/haskus-utils-variant)Set the value with the given indexed type0haskus-utils-variantSet the first value1haskus-utils-variant Set the tail2haskus-utils-variant(Get the value if it has the indexed type3haskus-utils-variantOPop a variant value by index, return either the value or the remaining variant4haskus-utils-variantPop the head of a variant value5haskus-utils-variant&Update a single variant value by index6haskus-utils-variant5Applicative update of a single variant value by index7haskus-utils-variantBind (>>=) for a Variant8haskus-utils-variantConst bind (>>) for a Variant9haskus-utils-variantPut a value into a Variant"Use the first matching type index.:haskus-utils-variant#Put a value into a Variant (silent)"Use the first matching type index.;haskus-utils-variantSplit a variant in two<haskus-utils-variant]Extract a type from a variant. Return either the value of this type or the remaining variant=haskus-utils-variant]Extract a type from a variant. Return either the value of this type or the remaining variant>haskus-utils-variant)Pick the first matching type of a VariantBfromVariantFirst @A (Variant 2 undefined :: V '[A,B,A]) == Nothing?haskus-utils-variant3Try to a get a value of a given type from a Variant@haskus-utils-variant<Try to a get a value of a given type from a Variant (silent)Ahaskus-utils-variant^Try to a get a value of a given type from a Variant that may not even support the given type.Bhaskus-utils-variant*Update of the first matching variant valueChaskus-utils-variant6Applicative update of the first matching variant valueDhaskus-utils-variant#Map the matching types of a variantEhaskus-utils-variant6Map the matching types of a variant and nub the resultFhaskus-utils-variant9Update a variant value with a variant and fold the resultGhaskus-utils-variant9Update a variant value with a variant and fold the resultHhaskus-utils-variant9Update a variant value with a variant and fold the resultIhaskus-utils-variant9Update a variant value with a variant and fold the resultJhaskus-utils-variant9Update a variant value with a variant and fold the resultKhaskus-utils-variantYAlter a variant. You need to specify the constraints required by the modifying function.Usage: alterVariant +NoConstraint id v alterVariant Resizable (resize 4) v- Multiple constraints: class (Ord a, Num a) => OrdNum a instance (Ord a, Num a) => OrdNum a alterVariant @OrdNum foo vLhaskus-utils-variant\Traverse a variant. You need to specify the constraints required by the modifying function.Mhaskus-utils-variant\Traverse a variant. You need to specify the constraints required by the modifying function.Nhaskus-utils-variantReduce a variant to a single value by using a class function. You need to specify the constraints required by the modifying function.%Usage: reduceVariant @Show show vOhaskus-utils-variant3Extend a variant by appending other possible valuesPhaskus-utils-variant4Extend a variant by prepending other possible valuesQhaskus-utils-variantLift a variant into another%Set values to the first matching typeRhaskus-utils-variantNub the type listShaskus-utils-variantProduct of two variantsThaskus-utils-variantFlatten variants in a variantUhaskus-utils-variant#Join on a variant in an unsafe way.-Works with IO for example but not with Maybe.Vhaskus-utils-variantRetrieve a single valueWhaskus-utils-variant$Create a variant from a single valueXhaskus-utils-variant+Convert a variant of two values in a EitherYhaskus-utils-variant<Lift an Either into a Variant (reversed order by convention)Zhaskus-utils-variant5Get variant possible values in a tuple of Maybe typesN !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZN)*.-+%$#/0123456FG789<=?A>BC!"DEHIJ KLMNOPQRSTU;&VWXYZ,@(:'Safe.>HUVXkvhaskus-utils-variantKCall the type-indexed continuation from the tuple passed as first parameterhaskus-utils-variant<Implicitly call the type-indexed continuation in the contexthaskus-utils-variantFCall the indexed continuation from the tuple passed as first parameterhaskus-utils-variant<Implicitly call the type-indexed continuation in the contexthaskus-utils-variantRecursive call None.=>?EHUVX_k-.haskus-utils-variant|Lift a tuple of functions (a -> r1, b -> r2, ...) into a tuple of functions (a -> V '[r1,r2,...], b -> V '[r1,r2,...], ...)haskus-utils-variant2Extract the RHS of every function type in the listhaskus-utils-variant8Replace the RHS of every function type in the list with vhaskus-utils-variant Control-flowhaskus-utils-variantReturn in the first elementhaskus-utils-variant&Return in the first well-typed elementhaskus-utils-variantReturn a single elementhaskus-utils-variantLift a flow into anotherhaskus-utils-variantLift a flow into a ContFlowhaskus-utils-variant'Traverse a list and stop on first errorhaskus-utils-variant'Traverse a list and stop on first errorhaskus-utils-variant,Traverse a list and return only valid valueshaskus-utils-variant,Traverse a list and return only valid valueshaskus-utils-variantExtract single flow resultphaskus-utils-variant:Lift an operation on a Variant into an operation on a flowhaskus-utils-variant6Map a pure function onto the correct value in the flowhaskus-utils-variant4Bind two flows in a monadish way (error types union)haskus-utils-variant6Bind two flows in a monadic way (constant error types)haskus-utils-variantMatch a value in a flowhaskus-utils-variantDMatch a value in a flow and use a non-returning failure in this casehaskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variant*Extract the first value, concat the resulthaskus-utils-variant+Extract the first value, concat the resultshaskus-utils-variant"Extract the first value, lift bothhaskus-utils-variant"Extract the first value, lift bothhaskus-utils-variant(Extract the first value, lift unselectedhaskus-utils-variant(Extract the first value, lift unselectedhaskus-utils-variant*Extract the first value, use the same tailhaskus-utils-variant*Extract the first value, use the same tailhaskus-utils-variant'Take the first output, union the resulthaskus-utils-variant(Take the first output, fusion the resulthaskus-utils-variantGExtract the first value and perform effect. Passthrough the input valuehaskus-utils-variantGExtract the first value and perform effect. Passthrough the input valuehaskus-utils-variant+Extract the first value and perform effect.haskus-utils-variant+Extract the first value and perform effect.haskus-utils-variant+Extract the first value and perform effect.haskus-utils-variant+Extract the first value and perform effect.haskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variantFunctor  $ equivalenthaskus-utils-variant Applicative  * equivalenthaskus-utils-variant Applicative  * equivalent, with error unionhaskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variant,Extract the first value, set the first valuehaskus-utils-variant*Extract the first value, concat the resulthaskus-utils-variant+Extract the first value, concat the resultshaskus-utils-variant(Extract the first value, lift the resulthaskus-utils-variant(Extract the first value, lift the resulthaskus-utils-variant7Extract the first value, connect to the expected outputhaskus-utils-variant7Extract the first value, connect to the expected outputhaskus-utils-variant1Extract the first value, use the same output typehaskus-utils-variant1Extract the first value, use the same output typehaskus-utils-variant(Take the first output, fusion the resulthaskus-utils-variant(Take the first output, fusion the resulthaskus-utils-variantGExtract the first value and perform effect. Passthrough the input valuehaskus-utils-variantGExtract the first value and perform effect. Passthrough the input valuehaskus-utils-variant+Extract the first value and perform effect.haskus-utils-variant+Extract the first value and perform effect.haskus-utils-variant%Extract the tail, set the first valuehaskus-utils-variant%Extract the tail, set the first valuehaskus-utils-variant5Extract the tail, set the first value (pure function)haskus-utils-variant5Extract the tail, set the first value (pure function)haskus-utils-variantExtract the tail, set the tailhaskus-utils-variantExtract the tail, set the tailhaskus-utils-variantExtract the tail, set the tailhaskus-utils-variantExtract the tail, set the tailhaskus-utils-variant!Extract the tail, lift the resulthaskus-utils-variant!Extract the tail, lift the resulthaskus-utils-variant$Extract the tail, connect the resulthaskus-utils-variant$Extract the tail, connect the resulthaskus-utils-variant1Match in the tail, connect to the expected resulthaskus-utils-variant1Match in the tail, connect to the expected resulthaskus-utils-variant1Match in the tail, connect to the expected resulthaskus-utils-variant1Match in the tail, connect to the expected resulthaskus-utils-variant.Match in the tail, lift to the expected resulthaskus-utils-variant.Match in the tail, lift to the expected resulthaskus-utils-variant.Match in the tail, lift to the expected resulthaskus-utils-variant.Match in the tail, lift to the expected resulthaskus-utils-variant&Match in the tail, keep the same typeshaskus-utils-variant&Match in the tail, keep the same typeshaskus-utils-variant&Match in the tail, keep the same typeshaskus-utils-variant&Match in the tail, keep the same typeshaskus-utils-variantCExtract the tail and perform an effect. Passthrough the input valuehaskus-utils-variantCExtract the tail and perform an effect. Passthrough the input valuehaskus-utils-variant&Extract the tail and perform an effecthaskus-utils-variant&Extract the tail and perform an effecthaskus-utils-variant&Extract the tail and perform an effecthaskus-utils-variant&Extract the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant'Match in the tail and perform an effecthaskus-utils-variant Pop element, set the first valuehaskus-utils-variant Pop element, set the first valuehaskus-utils-variant Pop element, set the first valuehaskus-utils-variant Pop element, set the first valuehaskus-utils-variantPop element, concat the resulthaskus-utils-variantPop element, concat the resulthaskus-utils-variantPop element, concat the resulthaskus-utils-variantPop element, concat the resulthaskus-utils-variantPop element, lift the resulthaskus-utils-variantPop element, lift the resulthaskus-utils-variantPop element, lift the resulthaskus-utils-variantPop element, lift the resulthaskus-utils-variant+Pop element, connect to the expected outputhaskus-utils-variant+Pop element, connect to the expected outputhaskus-utils-variant+Pop element, connect to the expected outputhaskus-utils-variant+Pop element, connect to the expected outputhaskus-utils-variant%Pop element, use the same output typehaskus-utils-variant%Pop element, use the same output typehaskus-utils-variant%Pop element, use the same output typehaskus-utils-variant%Pop element, use the same output typehaskus-utils-variantPop element, fusion the resulthaskus-utils-variantPop element, fusion the result haskus-utils-variantPop element, fusion the result haskus-utils-variantPop element, fusion the result haskus-utils-variant<Pop element and perform effect. Passthrough the input value. haskus-utils-variant<Pop element and perform effect. Passthrough the input value. haskus-utils-variant<Pop element and perform effect. Passthrough the input value.haskus-utils-variant<Pop element and perform effect. Passthrough the input value.haskus-utils-variantPop element and perform effect.haskus-utils-variantPop element and perform effect.haskus-utils-variantPop element and perform effect.haskus-utils-variantPop element and perform effect.haskus-utils-variantPop element and perform effect.haskus-utils-variantPop element and perform effect.haskus-utils-variantPop element and perform effect.haskus-utils-variantPop element and perform effect.haskus-utils-variantMake a flow operatorhaskus-utils-variantMake a flow operatorhaskus-utils-variantSelect the first valuehaskus-utils-variantSelect the tailhaskus-utils-variantSelect by typehaskus-utils-variantConst applicationhaskus-utils-variantPure applicationhaskus-utils-variantLift a monadic functionqhaskus-utils-variantLift a monadic functionhaskus-utils-variantLift a monadic function haskus-utils-variant'Set the first value (the "correct" one)!haskus-utils-variant-Set the first value, keep the same tail type "haskus-utils-variant#Return the valid variant unmodified#haskus-utils-variantConcatenate unselected values$haskus-utils-variantUnion%haskus-utils-variantLift unselected&haskus-utils-variant Lift both'haskus-utils-variant Single value(haskus-utils-variant7Lift a pure function into a Variant to Variant function)haskus-utils-variantLift a function into a Flow*haskus-utils-variantPure multi-map:Map functions on a variant and produce a resulting variant  > (V c :: V '[Char,String]) -|| (ord,map toUpper) V 99 :: V '[Int,String] > (V "test" :: V '[Char,String]) -|| (ord,map toUpper) V TESTc :: V '[Int,String] > (V "test" :: V '[Char,String]) -|| (ord,length) V 4 :: V '[Int,Int] +haskus-utils-variantApplicative pure multi-map,haskus-utils-variantMonadic pure multi-map-haskus-utils-variantVariant multi-mapdMap functions returning a variant on a variant and produce a resulting flattened and nub'ed variant f mapInt64 :: Int64 -> V '[Int16,Int32,Int64] mapInt64 x | x <= 0xffff = toVariantAt :0 (fromIntegral x) | x <= 0xffffffff = toVariantAt :1 (fromIntegral x) | otherwise = toVariantAt i2 x mapInt32 :: Int32 -> V '[Int16,Int32] mapInt32 x | x <= 0xffff = toVariantAt :0 (fromIntegral x) | otherwise = toVariantAt 1 x > V \Int64 @'[Int64,Int32] 10 ~|| (mapInt64,mapInt32) V 10 :: Variant '[Int16, Int32, Int64] .haskus-utils-variantApplicative variant multi-map  mapInt64 :: Int64 -> IO (V '[Int16,Int32,Int64]) mapInt64 x | x <= 0xffff = do putStrLn "Found Int16!" return (toVariantAt o0 (fromIntegral x)) | x <= 0xffffffff = do putStrLn "Found Int32!" return (toVariantAt o1 (fromIntegral x)) | otherwise = do putStrLn "Found Int64!" return (toVariantAt 2 x) mapInt32 :: Int32 -> IO (V '[Int16,Int32]) mapInt32 x | x <= 0xffff = do putStrLn "Found Int16!" return (toVariantAt o0 (fromIntegral x)) | otherwise = do putStrLn "Found Int32!" return (toVariantAt 1 x) v = V !Int64 @'[Int64,Int32] 10 > x  -v -||q (mapInt64,mapInt32) Found Int16! > :t x x :: V '[V '[Int16, Int32, Int64], V '[Int16, Int32]] > x  -v ~||Q (mapInt64,mapInt32) Found Int16! > :t x x :: V '[Int16, Int32, Int64] /haskus-utils-variantMonadic variant multi-map#%      !"#$%&'()*+,-./%#     *+,-./ !"#$%&'()s00000000000000000000004440000000000000000000000000000000000000000000000000000000000000000000000000000 0 0 0 0 0000000000None.>UVX;m9:;9:;None,.1=>?@AHSUVXgkR?haskus-utils-variantxs is liftable in ysBhaskus-utils-variant=Apply its first argument to every element of the 2nd arg list (ApplyAll e '[f,g,h] ==> '[f e, g e, h e]Chaskus-utils-variantRecursive Functor-like VariantEhaskus-utils-variantPattern-match in a VariantFFhaskus-utils-variantRetrieve a single valueHhaskus-utils-variantSet the first valueIhaskus-utils-variant Set the tailJhaskus-utils-variantPop VariantF headKhaskus-utils-variant Pop VariantFLhaskus-utils-variant#Map the matching types of a variantMhaskus-utils-variantLift a VariantF into anotherNhaskus-utils-variantYAlter a variant. You need to specify the constraints required by the modifying function.Usage:  alterVariantF @NoConstraint id v alterVariantF @Resizable (resize 4) v -- Multiple constraints: class (Ord a, Num a) => OrdNum a instance (Ord a, Num a) => OrdNum a alterVariantF @OrdNum foo vOhaskus-utils-varianthApply an algebra to a VariantF. You need to specify the constraints required by the modifying function.Usage: O algVariantF @NoConstraint id v algVariantF @Resizable (resize 4) vPhaskus-utils-variantSplit a VariantF in twoQhaskus-utils-variant,Convert a VariantF into a multi-continuationRhaskus-utils-variant,Convert a VariantF into a multi-continuationShaskus-utils-variant,Convert a multi-continuation into a VariantFThaskus-utils-variant,Convert a multi-continuation into a VariantFWrstuvwxyz{|}~ <=>?@ABCDEFGHIJKLMNOPQRSTCDBEGHIJF@LAK?M>N=O<PQRST None,.=>?HSUVXgk` ahaskus-utils-variantForall x in xs , `x :<: ys`bhaskus-utils-variant Constructor f is in xschaskus-utils-variantAn extensible ADTdhaskus-utils-variant"Pattern-match in an extensible ADTehaskus-utils-variant%Append new "constructors" to the EADTfhaskus-utils-variantLift an EADT into anotherghaskus-utils-variantPop an EADT valuehhaskus-utils-variantAlter an EADT valueihaskus-utils-variant!Apply an algebra to an EADT valuejhaskus-utils-variant)Convert an EADT into a multi-continuationkhaskus-utils-variant)Convert an EADT into a multi-continuationlhaskus-utils-variant)Convert a multi-continuation into an EADTmhaskus-utils-variant)Convert a multi-continuation into an EADTfrstuvwxyz{|}~ <=>?@ABCDEFGHIJKLMNOPQRST_`abcdefghijklmcbadefg`h_ijklmNoneUV_gxnhaskus-utils-variant0Create a pattern synonym for an EADT constructorE.g. data ConsF a e = ConsF a e deriving (Functor) $(eadtPattern 'ConsF "Cons") ====> pattern Cons :: ConsF a :<: xs => a -> EADT xs -> EADT xs pattern Cons a l = VF (ConsF a l)ohaskus-utils-variantSCreate a pattern synonym for an EADT constructor that is part of a specified EADT.This can be useful to help the type inference because instead of using a generic "EADT xs" type, the pattern uses the provided type.E.g. =data ConsF a e = ConsF a e deriving (Functor) data NilF e = NilF deriving (Functor) type List a = EADT '[ConsF a, NilF] $(eadtPatternT 'ConsF "ConsList" [t|forall a. List a|]) ====> pattern ConsList :: ( List a ~ EADT xs , ConsF a :<: xs ) => a -> List a -> List a pattern ConsList a l = VF (ConsF a l)>Note that you have to quantify free variables explicitly with forallhaskus-utils-variant0Create a pattern synonym for an EADT constructornhaskus-utils-variant Actual constructor (e.g., ConsF)haskus-utils-variant Name of the pattern (e.g., Cons)ohaskus-utils-variant Actual constructor (e.g., ConsF)haskus-utils-variant Name of the pattern (e.g., Cons)haskus-utils-variant.Type of the EADT (e.g., [t|forall a. List a|])haskus-utils-variant Actual constructor (e.g., ConsF)haskus-utils-variant Name of the pattern (e.g., Cons)haskus-utils-variant EADT typenono     !"#$%&'()*+,-./01234563789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzxyzxy{xy{xy|xy|xy}xy~xyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxy/haskus-utils-variant-2.2-D78HMT2F87XL44kkWNlPXRHaskus.Utils.VariantHaskus.Utils.ContFlowHaskus.Utils.Variant.ContHaskus.Utils.Variant.FlowHaskus.Utils.Variant.SyntaxHaskus.Utils.VariantFHaskus.Utils.EADTHaskus.Utils.EADT.TH-haskus-utils-types-1.2-3XwMXP2AMyiFt6tXM9gzySHaskus.Utils.Types.ListRemoveMember MultiContMultiContTypestoConttoContMStripRAddRContTupleToListContListToTupleContFlow>::>>:-:>>:%:> ContVariant variantToContvariantToContM contToVariantcontToVariantMvariantToHList JoinVariant joinVariantExtractM FlattenableFlattenVariant LiftVariant' liftVariant' LiftVariant ReduceVariantTraverseVariant AlterVariant NoConstraint ReplaceAll MapVariant:>.~.>.~+>>.~+>.~^^>>.~^^>.~^>>.~^>.~$>>.~$>.~|>>.~|>.~=>>.~=>.~!>>.~!>.~!!>>.~!!>.-.>>.-.><.-.<.-.<<$<<*<<|<.~~.>>.~~.>.~~+>>.~~+>.~~^^>>.~~^^>.~~^>>.~~^>.~~$>>.~~$>.~~|>>.~~|>.~~=>>.~~=>.~~!>>.~~!>..~.>>..~.>..-.>>..-.>..-..>>..-..>..~..>>..~..>..~^^>>..~^^>..~^>>..~^>..?~^>>..?~^>..%~^>>..%~^>..?~^^>>..?~^^>..%~^^>>..%~^^>..?~$>>..?~$>..%~$>>..%~$>..~=>>..~=>..~!>>..~!>..~!!>>..~!!>..?~!!>>..?~!!>..%~!!>>..%~!!>..?~!>>..?~!>..%~!>>..%~!>?~.>>?~.>%~.>>%~.>?~+>>?~+>%~+>>%~+>?~^^>>?~^^>%~^^>>%~^^>?~^>>?~^>%~^>>%~^>?~$>>?~$>%~$>>%~$>?~|>>?~|>%~|>>%~|>?~=>>?~=>%~=>>%~=>?~!>>?~!>%~!>>%~!>?~!!>>?~!!>%~!!>>%~!!> makeFlowOp makeFlowOpM selectFirst selectTail selectType applyConst applyPureapplyMapplyF combineFirstcombineSameTail combineEither combineConcat combineUnioncombineLiftUnselectedcombineLiftBoth combineSingleliftVliftF-||-||>>-||>~||~||>>~||>$fLiftCont(,,,,,,,,)$fLiftCont(,,,,,,,)$fLiftCont(,,,,,,)$fLiftCont(,,,,,)$fLiftCont(,,,,)$fLiftCont(,,,)$fLiftCont(,,) $fLiftCont(,)$fLiftContSingle>>=>>return SplitVariantF AlgVariantF AlterVariantF LiftVariantF MapVariantF PopVariantFApplyAllVariantFFVvariantFToValueappendVariantFtoVariantFHeadtoVariantFTailpopVariantFHead popVariantF mapVariantF liftVariantF alterVariantF algVariantF splitVariantFvariantFToContvariantFToContMcontToVariantFcontToVariantFM$fMultiContVariantF$fFunctorVariantF$fFunctorVariantF0$fShowVariantF$fAlterVariantFce:$fAlterVariantFce[]$fAlgVariantFce:$fAlgVariantFce[] $fOrdVariantF $fEqVariantFAlgEADT AlterEADT:<<::<:EADTVF appendEADTliftEADTpopEADT alterEADTalgEADT eadtToCont eadtToContM contToEADT contToEADTM eadtPattern eadtPatternTliftmapplyVM.recursion-schemes-5.0.3-K6tceNrtle5KGW4jkfhxwaData.Functor.FoldableNuMuFixListFNilCons Corecursiveembedanaapopostprogpostpro RecursiveprojectcataparagparapreprogpreproBasedistPara distParaThylofoldunfoldrefoldgcatagfolddistCataganagunfolddistAnaghylogrefoldfutudistFutu distGFutuunfixrefixzygodistZygogzygo distZygoTgapodistApodistGApo distGApoThistoghisto distHisto distGHistochronogchronomcatamhistoelgotcoelgotzygoHistoPrepro eadtPattern'