úÎâñ×'¬      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«Safe 7¬ A strict ­® A strict ¯°Convert ® to ¯±Convert ¯ to ®²Convert ¬ to ¯ ³´¬µ¶®·¸°±²³´¬µ¶®·¸ Trustworthy<CQV‹ÄL$A Handler for the upstream input of 3Any lens, traversal, or prism will type-check as a  xinstance Monad m => Monoid (EndoM m a) where mempty = EndoM return mappend (EndoM f) (EndoM g) = EndoM (f <=< g)&A handler for the upstream input of a 3Any lens, traversal, or prism will type-check as a Like , but monadic.A '# m a b' processes elements of type a, and results in a monadic value of type m b.FoldM   step   initial   extractEfficient representation of a left fold that preserves the fold's step function, initial accumulator, and extraction functionThis allows the ¹M instance to assemble derived folds that traverse the container only onceA '! a b' processes elements of type a$ and results in a value of type b.Fold   step   initial   extract Apply a strict left  to a º container Like   , but monadic Convert a strict left  into a scan  Convert a  into a prescan for any » typeA"Prescan" means that the last element of the scan is not included  Convert a  into a postscan for any » typeC"Postscan" means that the first element of the scan is not included)Fold all values within a container using ¼ and ½ Convert a "foldMap" to a /Get the first element of a container or return ¾ if the container is empty.Get the last element of a container or return ¾ if the container is empty[Get the last element of a container or return a default value if the container is emptyReturn the last N elementsReturns ¿ if the container is empty, À otherwise"Return the length of the containerReturns ¿ if all elements are ¿, À otherwiseReturns ¿ if any element is ¿, À otherwise(all predicate) returns ¿, if all elements satisfy the predicate, À otherwise(any predicate) returns ¿- if any element satisfies the predicate, À otherwise Computes the sum of all elements$Computes the product of all elements<Compute a numerically stable arithmetic mean of all elementsDCompute a numerically stable (population) variance over all elementsRCompute a numerically stable (population) standard deviation over all elementsComputes the maximum element NComputes the maximum element with respect to the given comparison function!Computes the minimum element"NComputes the minimum element with respect to the given comparison function#(elem a) returns ¿* if the container has an element equal to a, À otherwise$ (notElem a) returns À* if the container has an element equal to a, ¿ otherwise%(find predicate)? returns the first element that satisfies the predicate or ¾& if no element satisfies the predicate& (index n) returns the n th element of the container, or ¾< if the container has an insufficient number of elements' (elemIndex a)4 returns the index of the first element that equals a , or ¾ if no element matches((findIndex predicate)M returns the index of the first element that satisfies the predicate, or ¾& if no element satisfies the predicate) (lookup a)A returns the element paired with the first matching item, or ¾ if none matches*/Pick a random element, using reservoir sampling+6Pick several random elements, using reservoir sampling,AConverts an effectful function to a fold. Specialized version of -.-(Converts an effectful function to a fold Qsink (f <> g) = sink f <> sink g -- if `(<>)` is commutative sink mempty = mempty.Like , except with a more general Á return value/Like &, except with a more general  argument0Fold all values into a list1-Fold all values into a list, in reverse order2 O(n log n)`. Fold values into a list with duplicates removed, while preserving their first occurrences3O(n^2)`. Fold values into a list with duplicates removed, while preserving their first occurrences4Fold values into a set5Fold values into a hash-set6Fold pairs into a map.7Fold pairs into a hash-map.8Fold all values into a vector9Fold all values into a vectorThis is more efficient than 8 but is impure:Upgrade a fold to accept the  type;.Upgrade a more traditional fold to accept the  type<%Upgrade a monadic fold to accept the  type=6Upgrade a more traditional monadic fold to accept the  type> Generalize a  to a  Rgeneralize (pure r) = pure r generalize (f <*> x) = generalize f <*> generalize x?Simplify a pure  to a  Jsimplify (pure r) = pure r simplify (f <*> x) = simplify f <*> simplify x@Shift a 3 from one monad to another with a morphism such as lift or liftIO!; the effect is the same as .AAllows to continue feeding a 4 even after passing it to a function that closes it. For pure s, this is provided by the à instance.B _Fold1 step returns a new ‹ using just a step function that has the same type for the accumulator and the element. The result type is the accumulator type wrapped in ¯0. The initial accumulator is retrieved from the º, the result is None for empty containers.C(premap f folder) returns a new  where f is applied at each step 6fold (premap f folder) list = fold folder (map f list)!fold (premap Sum mconcat) [1..10]Sum {getSum = 55}fold mconcat (map Sum [1..10])Sum {getSum = 55} 4premap id = id premap (f . g) = premap g . premap f Jpremap k (pure r) = pure r premap k (f <*> x) = premap k f <*> premap k xD(premapM f folder) returns a new - where f is applied to each input element <premapM return = id premapM (f <=< g) = premap g . premap f NpremapM k (pure r) = pure r premapM k (f <*> x) = premapM k f <*> premapM k xE(prefilter f folder) returns a new O where the folder's input is used only when the input satisfies a predicate fThis can also be done with G (handles (filtered f)) but  prefilter1 does not need you to depend on a lens library. <fold (prefilter p folder) list = fold folder (filter p list)/fold (prefilter (>5) Control.Foldl.sum) [1..10]40,fold Control.Foldl.sum (filter (>5) [1..10])40F(prefilterM f folder) returns a new X where the folder's input is used only when the input satisfies a monadic predicate f. ?foldM (prefilterM p folder) list = foldM folder (filter p list)G(handles t folder) transforms the input of a ' using a lens, traversal, or prism: Ýhandles _1 :: Fold a r -> Fold (a, b) r handles _Left :: Fold a r -> Fold (Either a b) r handles traverse :: Traversable t => Fold a r -> Fold (t a) r handles folded :: Foldable t => Fold a r -> Fold (t a) r,fold (handles traverse sum) [[1..5],[6..10]]55^fold (handles (traverse.traverse) sum) [[Nothing, Just 2, Just 7],[Just 13, Nothing, Just 20]]42*fold (handles (filtered even) sum) [1..10]30<fold (handles _2 mconcat) [(1,"Hello "),(2,"World"),(3,"!")]"Hello World!" 8handles id = id handles (f . g) = handles f . handles g Nhandles t (pure r) = pure r handles t (f <*> x) = handles t f <*> handles t xH(foldOver f folder xs)M folds all values from a Lens, Traversal, Prism or Fold with the given folder+foldOver (_Just . both) L.sum (Just (2, 3))5%foldOver (_Just . both) L.sum Nothing0 0L.foldOver f folder xs == L.fold folder (xs^..f) 9L.foldOver (folded.f) folder == L.fold (handles f folder) L.foldOver folded == L.foldI(handlesM t folder) transforms the input of a ' using a lens, traversal, or prism: õhandlesM _1 :: FoldM m a r -> FoldM (a, b) r handlesM _Left :: FoldM m a r -> FoldM (Either a b) r handlesM traverse :: Traversable t => FoldM m a r -> FoldM m (t a) r handlesM folded :: Foldable t => FoldM m a r -> FoldM m (t a) rI obeys these laws: <handlesM id = id handlesM (f . g) = handlesM f . handlesM g RhandlesM t (pure r) = pure r handlesM t (f <*> x) = handlesM t f <*> handlesM t xJ(foldOverM f folder xs)Y folds all values from a Lens, Traversal, Prism or Fold monadically with the given folder <L.foldOverM (folded.f) folder == L.foldM (handlesM f folder) L.foldOverM folded == L.foldMK ^folded :: Foldable t => Fold (t a) a handles folded :: Foldable t => Fold a r -> Fold (t a) rL*fold (handles (filtered even) sum) [1..10]306foldM (handlesM (filtered even) (mapM_ print)) [1..10]246810M Perform a ‹ while grouping the data according to a specified group projection function. Returns the folded result grouped as a map keyed by the group.SºÄÅÆÇ  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN  !"#$%&)'(*+,-./0123456789:;<=>?@ABCDEFGHIJKLMÈÉÊËÌÍÎÏÐÑÒNone£zbApply a strict left  to a lazy bytestringcApply a strict monadic left  to a lazy bytestringd.Get the first byte of a byte stream or return ¾ if the stream is emptye-Get the last byte of a byte stream or return ¾ if the byte stream is emptyfReturns ¿ if the byte stream is empty, À otherwiseg-Return the length of the byte stream in bytesh(all predicate) returns ¿% if all bytes satisfy the predicate, À otherwisei(any predicate) returns ¿* if any byte satisfies the predicate, À otherwisejComputes the maximum bytekComputes the minimum bytel (elem w8) returns ¿( if the byte stream has a byte equal to w8, À otherwisem (notElem w8) returns À( if the byte stream has a byte equal to w8, ¿ otherwisen(find predicate)< returns the first byte that satisfies the predicate or ¾# if no byte satisfies the predicateo (index n) returns the nth byte of the byte stream, or ¾6 if the stream has an insufficient number of bytesp(elemIndex w8)1 returns the index of the first byte that equals w8 , or ¾ if no byte matchesq(findIndex predicate)J returns the index of the first byte that satisfies the predicate, or ¾# if no byte satisfies the predicatercount w8 returns the number of times w8 appearssCombine all the strict Ó chunks to build a lazy ÓºÔÓbcdefghijklmnopqrsbcdefgihjklmnopqrsSafeºtApply a strict left  to lazy textuApply a strict monadic left  to lazy textv3Get the first character of a text stream or return ¾ if the stream is emptyw2Get the last character of a text stream or return ¾ if the text stream is emptyxReturns ¿ if the text stream is empty, À otherwisey2Return the length of the text stream in charactersz(all predicate) returns ¿. if all characters satisfy the predicate, À otherwise{(any predicate) returns ¿/ if any character satisfies the predicate, À otherwise|Computes the maximum character}Computes the minimum character~(elem c) returns ¿- if the text stream has a character equal to c, À otherwise (notElem c) returns À1 if the text stream has a character equal to c, ¿ otherwise€(find predicate)A returns the first character that satisfies the predicate or ¾( if no character satisfies the predicate (index n) returns the n$th character of the text stream, or ¾; if the stream has an insufficient number of characters‚ (elemIndex c)6 returns the index of the first character that equals c , or ¾ if no character matchesƒ(findIndex predicate)O returns the index of the first character that satisfies the predicate, or ¾, if no character satisfies the predicate„ (count c) returns the number of times c appears…Combine all the strict Õ chunks to build a lazy ÕºÕtuvwxyz{|}~€‚ƒ„…tuvwxy{z|}~€‚ƒ„…Safe<CNQVÖ†Like ˆ, but monadic.A '†# m a b' processes elements of type a, and results in a monadic value of type m b.‡ScanM   step   initial   extractˆ|Efficient representation of a left map-with-accumulator that preserves the scan's step function and initial accumulator.This allows the ¹M instance to assemble derived scans that traverse the container only onceA 'ˆ! a b' processes elements of type a) replacing each with a value of type b.‰Scan   step   initial ŠApply a strict left ˆ to a » container‹Like Š but monadicŒ Convert a  into a prescanA"Prescan" means that the last element of the scan is not included Convert a  into a postscanC"Postscan" means that the first element of the scan is not includedUpgrade a scan to accept the ˆ type.Upgrade a more traditional scan to accept the ˆ type‘%Upgrade a monadic scan to accept the † type’6Upgrade a more traditional monadic scan to accept the † type“ Generalize a ˆ to a † Rgeneralize (pure r) = pure r generalize (f <*> x) = generalize f <*> generalize x”Simplify a pure † to a ˆ Jsimplify (pure r) = pure r simplify (f <*> x) = simplify f <*> simplify x•Shift a †3 from one monad to another with a morphism such as Ö or liftIO!; the effect is the same as .–(premap f scaner) returns a new ˆ where f is applied at each step 6scan (premap f scaner) list = scan scaner (map f list) 4premap id = id premap (f . g) = premap g . premap f Jpremap k (pure r) = pure r premap k (f <*> x) = premap k f <*> premap k x—(premapM f scaner) returns a new †- where f is applied to each input element <premapM return = id premapM (f <=< g) = premap g . premap f NpremapM k (pure r) = pure r premapM k (f <*> x) = premapM k f <*> premapM k x†‡ˆ‰Š‹ŒŽ‘’“”•–—ˆ‰†‡Š‹Œ‘’“”•Ž–—†‡ˆ‰×         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef$&()*+,-gh$&()*+,-ghiijjkl?@ABCDEHImnopqrstuvwxyz{|}~€‚ƒ„…‚†‡hˆ‰ŠŠ‹ŒŽ‚†‚‘‚’“‚†”‚†•‚†–—˜™—˜š‚›œ‚žŸ ¡—¢£¤¥¦§¨©§¨ª««¬­®¯°±²³³´µ¶‚·¸¹º»¼½¾¿"foldl-1.4.1-6AslQk0mpoBK6jUkYnc58c Control.FoldlControl.Foldl.ByteStringControl.Foldl.Text Control.ScanlControl.Foldl.InternalControl.Monad.MorphhoistHandlerMEndoMappEndoMHandlerFoldMFoldfoldfoldMscanprescanpostscanmconcatfoldMapheadlastlastDeflastNnulllengthandorallanysumproductmeanvariancestdmaximum maximumByminimum minimumByelemnotElemfindindex elemIndex findIndexlookuprandomrandomNmapM_sink genericLength genericIndexlistrevListnubeqNubsethashSetmaphashMapvectorvectorMpurelypurely_impurely impurely_ generalizesimplifyhoists duplicateM_Fold1premappremapM prefilter prefilterMhandlesfoldOverhandlesM foldOverMfoldedfilteredgroupBy$fFloatingFold$fFractionalFold $fNumFold $fMonoidFold$fSemigroupFold$fApplicativeFold $fComonadFold $fChoiceFold$fProfunctorFold $fFunctorFold$fFloatingFoldM$fFractionalFoldM $fNumFoldM $fMonoidFoldM$fSemigroupFoldM$fProfunctorFoldM$fApplicativeFoldM$fFunctorFoldM $fMonoidEndoM$fSemigroupEndoMcountlazyScanMScanscanMarrM$fFloatingScan$fFractionalScan $fNumScan $fMonoidScan$fSemigroupScan $fArrowScan$fCategoryTYPEScan$fProfunctorScan$fApplicativeScan $fFunctorScan$fFloatingScanM$fFractionalScanM $fNumScanM $fMonoidScanM$fSemigroupScanM $fArrowScanM$fCategoryTYPEScanM$fProfunctorScanM$fApplicativeScanM$fFunctorScanMEither'base Data.EitherEitherMaybe'GHC.BaseMaybestricthushPairLeft'Right'Just'Nothing' Applicative Data.FoldableFoldableData.Traversable TraversablemappendmemptyNothingghc-prim GHC.TypesTrueFalseGHC.NumNumGHC.RealIntegral$comonad-5.0.3-IUy9MfvMWmVALWLTZ8cwfgControl.ComonadComonadGHC.Prim RealWorld(primitive-0.6.2.0-EI3NK1Xfv9zEcRtyXK2EwZControl.Monad.Primitive PrimMonad&vector-0.12.0.1-LflPw1fguMb6as60UrZpxNData.Vector.Generic.BaseMutableVector RandomNState_size _reservoir _position_gen VectorState IncompleteCompletePair3bytestring-0.10.8.2Data.ByteString.Internal ByteStringGHC.WordWord8#text-1.2.2.2-EakMpasry3jA6OIwSZhq9MData.Text.InternalTexttransformers-0.5.2.0Control.Monad.Trans.Classlift