Fԑ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ portable experimentalconal@conal.net Safe-InferedMPTC experimentalconal@conal.net Safe-Infered!Class of monads with references. Change the contents of a ref  TypeOperators experimentalconal@conal.net Safe-InferedBijective functions A type of bijective arrows )Bijective identity arrow. Warning: uses  on (~>) . If you  have no , but you have a  DeepArrow, you can instead use Bi idA  idA. Inverse bijection Bijections on functors Bijections on arrows. AApply a function in an alternative (monomorphic) representation.         see LANGUAGE pragma experimentalconal@conal.netNone>0Arrow-like type between type constructors (doesn' t enforce Arrow  (~>) here). $Pairing of binary type constructors #Pairing of unary type constructors 'Identity type constructor. Until there's a better place to find it.  I'd use Control.Monad.Identity , but I don't want to introduce a  dependency on mtl just for Id.  Compatibility synonym for (:$). Type application  We can also drop the App, constructor, but then we overlap with many  other instances, like [a]. Here's a template for App-free  instances. = instance (Applicative f, Monoid a) => Monoid (f a) where  mempty = pure mempty  mappend = liftA2 mappend Convert to an !. !(-> IO ()) as a ". A ContraFunctor. "Flip type arguments %Simulates universal constraint forall a. Monoid (f a). ,See Simulating Quantified Class Constraints  ( 1http://flint.cs.yale.edu/trifonov/papers/sqcc.pdf) . Instantiate this schema wherever necessary: J instance Monoid_f f where { mempty_f = mempty ; mappend_f = mappend } (Support needed for a . to be an . .Common pattern for s. 1=Composition of type constructors: unary with binary. Called   StaticArrow in [1]. 4Compatibility synonym 5'Composition of unary type constructors  There are (at least) two useful  instances, so you' ll have to <pick one and type-specialize it (filling in all or parts of g and/or f).  C -- standard Monoid instance for Applicative applied to Monoid L instance (Applicative (g :. f), Monoid a) => Monoid ((g :. f) a) where : { mempty = pure mempty; mappend = liftA2 mappend } / -- Especially handy when g is a Monoid_f. < instance Monoid (g (f a)) => Monoid ((g :. f) a) where 5 { mempty = O mempty; mappend = inO2 mappend } 9Corresponding to the first and second definitions above,  E instance (Applicative g, Monoid_f f) => Monoid_f (g :. f) where M { mempty_f = O (pure mempty_f); mappend_f = inO2 (liftA2 mappend_f) } 4 instance Monoid_f g => Monoid_f (g :. f) where = { mempty_f = O mempty_f; mappend_f = inO2 mappend_f }  Similarly, there are two useful  instances and two useful 7 instances.  Y instance ( Functor g, Functor f) => Functor (g :. f) where fmap = fmapFF Y instance (ContraFunctor g, ContraFunctor f) => Functor (g :. f) where fmap = fmapCC  k instance ( Functor g, ContraFunctor f) => ContraFunctor (g :. f) where contraFmap = contraFmapFC k instance (ContraFunctor g, Functor f) => ContraFunctor (g :. f) where contraFmap = contraFmapCF  However, it'4s such a bother to define the Functor instances per composition type, I'4ve left the fmapFF case in. If you want the fmapCC one, you're out of luck for now. I''d love to hear a good solution. Maybe Jsomeday Haskell will do Prolog-style search for instances, subgoaling the 7constraints, rather than just matching instance heads. 7*Contravariant functors. often useful for  acceptors (consumers,  sinks) of values. 9Binary functions :Unary functions ;Add pre-processing  argument :: (a' -> a) -> ((a -> b) -> (a' -> b)) <Add post-processing =Add pre- and post processing >Like '(~>)', but specialized to functors and functions. ?%Bijections on contravariant functors @ Unwrap a '(:.)'. Anewtype bijection B#Compose a bijection, Functor style C)Compose a bijection, ContraFunctor style D"Apply a unary function within the 4 constructor. E#Apply a binary function within the 4 constructor. F$Apply a ternary function within the 4 constructor. GHandy combination of 4 and . HHandy combination of D and . IHandy combination of E and . JHandy combination of F and . K Used for the Functor :. Functor instance of  L Used for the ContraFunctor :. ContraFunctor instance of  M Used for the Functor :. ContraFunctor instance of  N Used for the ContraFunctor :. Functor instance of  O.-like function for implicitly composed monads P.-like function for explicitly composed monads QApply unary function in side a . representation. R Apply binary function in side a . representation. Snewtype bijection Wnewtype bijection ]newtype bijection ^newtype bijection _Compose a bijection `Apply unary function inside of f :*: g representation. a Apply binary function inside of f :*: g representation. b!Apply ternary function inside of f :*: g representation. cA handy combining form. See '(***#)' for an sample use. d=Combine two binary functions into a binary function on pairs e Apply binary function inside of f :*: g representation. f Apply binary function inside of f :*: g representation. gApply unary function inside of Arrw representation. h Apply binary function inside of  Arrw (~>) f g representation. i!Apply ternary function inside of  Arrw (~>) f g representation. jnewtype bijection kCompose a bijection lnewtype bijection pnewtype bijection q/Convenience for partial-manipulating functions  !"#$%&'()for  *+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqc !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqc:9<;=>78?564@ABCDEFGHIJKLMNOP123./0QR()*+,-%&'"#$STUV! WXYZ][\^_dc`abefjkghilmnopqi !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqportable experimentalconal@conal.netNonesu for all applications of f tFProvide a title on a value. If you can title polymorphically, please  instantiate r instead of Title. Then you'll automatically  get a t. for each type instance, thanks to this rule.   ; instance Title_f f => Title (f a) where title = title_f #To handle ambiguity for types like ([] Char) -- aka , this  module is compiled with OverlappingInstances and  UndecidableInstances,. The more specific instance (yours) wins. FIn defining your instance, you might want to use the String instance,  e.g.,  title ttl "". rsturstutursrstusynonym instance experimentalconal@conal.netNonevDType of context-dependent monoid. Includes an explicit dictionary. yDictionary for v. znewtype bijection vwxyzvwxyzyvwxzvwxyzGHC experimentalconal@conal.net Safe-Infered {Dual to ~. . Especially handy for contravariant functors (7) . Use this  template (filling in f) : / instance ContraFunctor f => Copair f where 4 { cofsts = cofmap fst ; cosnds = cofmap snd } ~6Unpairpable. Minimal instance definition: either (a)  or (b)  both of  and ). A standard template to substitute any   f. But watch out for effects! M instance Functor f => Unpair f where {fsts = fmap fst; snds = fmap snd} Type of  method. Generalizes . Type constructor class for -like things. A Here are some standard instance templates you can fill in. They're not I defined in the general forms below, because they would lead to a lot of  overlap.  + instance Applicative f => Pair f where  pair = liftA2 (,) < instance (Applicative h, Pair f) => Pair (h :. f) where  pair = apPair : instance (Functor g, Pair g, Pair f) => Pair (g :. f)  where pair = ppPair J instance (Arrow (~>), Unpair f, Pair g) => Pair (Arrw (~>) f g) where  pair = arPair 4 instance (Monoid_f h, Copair h) => Pair h where  pair = copair )Also, if you have a type constructor that's a  and a ,  here is a way to define '( *)' for :   (<*>) = pairWith ($) #Minimum definitions for instances. Type of  method  Handy for  instances  Handy for  instances  Pairing of  values. Warning: definition uses  , so only ! use if your arrow has a working .  Pairing of {) values. Combines contribution of each. ;Turn a pair of sources into a source of pair-editors. See   6http://conal.net/blog/posts/pairs-sums-and-reactivity/.  'Functor'\/'Monoid' version. See also . ;Turn a pair of sources into a source of pair-editors. See   6http://conal.net/blog/posts/pairs-sums-and-reactivity/.  Monad version. See also . &{| Pair-like value from first part }!Pair-like value from second part ~generalized unpair First part of pair-like value Second part of pair-like value  Generalized  {|}~~{|} {|}~GHC experimentalconal@conal.net Safe-Infered Dual to . . Especially handy for contravariant functors ( Cofunctor) . Use this  template (filling in f) : * instance Cofunctor f => Cozip f where 4 { cofsts = cofmap fst ; cosnds = cofmap snd } 5Unzippable. Minimal instance definition: either (a)  or (b)  both of  and ). A standard template to substitute any   f. But watch out for effects! L instance Functor f => Unzip f where {fsts = fmap fst; snds = fmap snd} Type of  method. Generalizes . Type constructor class for -like things. A Here are some standard instance templates you can fill in. They're not I defined in the general forms below, because they would lead to a lot of  overlap.  * instance Applicative f => Zip f where  zip = liftA2 (,) : instance (Applicative h, Zip f) => Zip (h :. f) where  zip = apZip 7 instance (Functor g, Zip g, Zip f) => Zip (g :. f)  where zip = ppZip G instance (Arrow (~>), Unzip f, Zip g) => Zip (Arrw (~>) f g) where  zip = arZip 2 instance (Monoid_f h, Cozip h) => Zip h where  zip = cozip )Also, if you have a type constructor that's a  and a ,  here is a way to define '( *)' for :   (<*>) = zipWith ($) #Minimum definitions for instances. Type of  method  Generalized   Generalized   Handy for  instances  Handy for  instances  Ziping of  values. Warning: definition uses  , so only ! use if your arrow has a working .  Ziping of ) values. Combines contribution of each. ;Turn a pair of sources into a source of pair-editors. See   6http://conal.net/blog/posts/pairs-sums-and-reactivity/.  'Functor'\/'Monoid' version. See also . ;Turn a pair of sources into a source of pair-editors. See   6http://conal.net/blog/posts/pairs-sums-and-reactivity/.  Monad version. See also . (Zip-like value from first part  Zip-like value from second part generalized unzip First part of pair-like value Second part of pair-like value  Generalized       "     portable experimentalconal@conal.net Safe-Infered8Partial value. Represented an endomorphism, which is a   under  and '(.)'. Then $ is the completely undefined value,  and in u  `@'mappend'@` v, v selectively replaces parts of u. The   instances for Pair, Unpair, Copair, Unfun, and Cofun ( are all very useful on partial values. :Treat a full value as a partial one. Fully overrides any  "previous" (earlier argument to mappend) partial value. AForce a partial value into a full one, filling in bottom for any  missing parts.  Inverse to "element"0 access, on all elements. A way to inject some  info about every element. For f , consider '[]', (->) a,  Event, etc. *Provide in info about a function argument %Provide info about a function result ?Inject a partial argument-source into a partial function-sink.   multi-parameter type classes experimentalconal@conal.net Safe-InferedLike Copair, but for functions Like Unpair>, but for functions. Minimal instance definition: either (a)   or (b) both of  and . Deconstruct pair-like value First part of pair-like value Second part of pair-like value QType constructor class for function-like things having lambda-like construction. Type of  method. Think of src as the bound variable (or  pattern) part of a lambda and snk as the expression part. They / combine to form a function-typed expression.  Instance template:  , instance (Applicative f, Lambda src snk) + => Lambda (f :. src) (f :. snk) where  lambda = apLambda Form a function-like value   !    !"##$%$&'()**+,-./012345567789:9;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~                   !"TypeCompose-0.9.3 Data.RefMonadData.BijectionControl.Compose Data.Title Data.CxMonoid Data.PairData.Zip Data.Partial Data.LambdaControl.InstancesRefMonadnewRefreadRefwriteRef modifyRef:<->: BijectionBibiTobiFromidbinversebimap--->inBi:->:ArrwunArrw::*::ProddunProdd:*:ProdunProdIdApp:$unAppToOItoOIOIFlipunFlipMonoid_fmempty_f mappend_fFunAblearrFunfirstFun secondFun***%&&&%FunAunFunAOOunOOO:. ContraFunctor contraFmapBinopUnopargumentresult~>~>*bicomapunObiOconvOcoconvOinOinO2inO3oPureoFmapoLiftA2oLiftA3fmapFFfmapCC contraFmapFC contraFmapCFjoinMMT joinComposeTinFunAinFunA2biFlipinFlipinFlip2inFlip3biAppinAppinApp2unIdinIdinId2biIdbiProdconvProdinProdinProd2inProd3$****#inProddinProdd2inArrwinArrw2inArrw3biFunconvFunbiConstinConstinConst2inConst3biEndoinEndoTitle_ftitle_fTitletitleCxMonoid unCxMonoid MonoidDict biCxMonoidCopaircofstscosndsUnpairunpairfstssndsUnpairTyPairpairPairTyapPairppPairarPaircopairpairEdit pairEditMCozipUnzipunzipUnzipTyZipzipZipTyzipWithzipWith3apZipppZiparZipcozipPartialXPartialvalppvalpUnEltpUnArgpUnRespUnSrcColambdacoresUnlambdaunlambdafsrcfresLambdalambdaLambdaTy $fMonoidIO$fRefMonadSTSTRef$fRefMonadIOIORefbase Control.Arrowarr$fArrowBijection$fCategoryBijectionArrow Data.MonoidMonoidGHC.BaseFunctorControl.ApplicativepurefmapliftA2liftA3 Control.Monadjoin$fMonoid_fEndo $fMonoidConst$fContraFunctorArrw $fFunctorArrw $fArrow::*::$fCategory::*::$fApplicative:*: $fFunctor:*: $fMonoid_f:*:$fOrd:*:$fEq:*: $fShow:*:$fTraversableId $fFoldableId $fMonadId$fApplicativeId $fFunctorId $fMonoid:$ $fToOIFlip$fMonoid_fFlip $fMonoidFlip$fContraFunctorFlip $fMonoid_f[] $fArrowFunA$fCategoryFunA $fArrowOO $fCategoryOO$fApplicative:.$fTraversable:. $fFoldable:. $fFunctor:.String $fTitle_fFlip $fTitle(->) $fTitle_fIO $fTitle[]$fTitlef $fTitle_f:.$fTitleCxMonoid$fMonoidCxMonoid Applicative $fPairEndo $fCopairEndo $fUnpairEndo $fCopair:*: $fCopair:. $fCopairFlip $fCopairConst $fUnpairId $fUnpairConst $fUnpair(,) $fUnpair(->) $fUnpair[] $fPair:*: $fPairArrw $fPairFlip$fPairId $fPairConst$fPairIO $fPair(->) $fPair(,)$fPair[]GHC.List $fZipEndo $fCozipEndo $fUnzipEndo $fCozip:*: $fCozip:. $fCozipFlip $fCozipConst $fUnzipId $fUnzipConst $fUnzip(,) $fUnzip(->) $fUnzip[]$fZip:*: $fZipArrw $fZipFlip$fZipId $fZipConst$fZipIO $fZip(->)$fZip(,)$fZip[]idmemptyEndo $fFunAbleEndo$fColambdaEndo$fUnlambdaEndoEndo$fLambdaArrwArrw$fLambda:*::*: $fLambdafArrw $fLambdaf:. $fLambdaf:.0$fLambdaIOFlip$fLambdaIdFlip