e7\f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeportable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedRA refinement of Integral to represent types that do not contain negative numbers. fghijklmnopqrfghijklmnopqrportable provisionalEdward Kmett <ekmett@gmail.com> Safe-Inferedportable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered'!(Extract the first element of the stream ".Extract the possibly empty tail of the stream #'Extract the last element of the stream $9Extract everything except the last element of the stream %cons onto a stream 'Sort a stream ((Converts an non-empty list to a stream. )'Convert a stream to a list efficiently *map a function over a  stream +The + function takes a stream xs and returns all the  finite prefixes of xs. ,The , function takes a stream xs and returns all the  suffixes of xs. -- an item into a  .. is similar to s%, but returns a stream of successive  reduced values from the left:  D scanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...]  Note that & last (scanl f z xs) == foldl f z xs. // is the right-to-left dual of ..  Note that & head (scanr f z xs) == foldr f z xs. 00 is a variant of .& that has no starting value argument: F scanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...] 11 is a variant of /& that has no starting value argument. 33 f x produces the infinite sequence  of repeated applications of f to x. % iterate f x = [x, f x, f (f x), ..] 44 xs$ returns the infinite repetition of xs: & cycle [1,2,3] = 1 :| [2,3,1,2,3,...] 55 a finite NonEmpty 66 x3 returns a constant stream, where all elements are  equal to x. 77 n xs returns the first n elements of xs. Beware8: passing a negative integer as the first argument will  cause an error. 88 n xs drops the first n elements off the front of  the sequence xs. Beware8: passing a negative integer as the first argument will  cause an error. 99 n xs, returns a pair consisting of the prefix of xs  of length n= and the remaining stream immediately following this prefix. Beware8: passing a negative integer as the first argument will  cause an error. :: p xs* returns the longest prefix of the stream  xs for which the predicate p holds. ;; p xs$ returns the suffix remaining after  : p xs. << p xs returns the longest prefix of xs that satisfies  p-, together with the remainder of the stream. =The = p function is equivalent to < not . p. >> p xs, removes any elements from xs that do not satisfy p. ?The ? function takes a predicate p and a stream  xs>, and returns a pair of streams. The first stream corresponds  to the elements of xs for which p holds; the second stream  corresponds to the elements of xs for which p does not hold. @The @1 function takes a stream and returns a stream of A lists such that flattening the resulting stream is equal to the ; argument. Moreover, each sublist in the resulting stream - contains only equal elements. For example, b group $ cycle "Mississippi" = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ... DThe isPrefix function returns True if the first argument is  a prefix of the second. Exs !! n# returns the element of the stream xs at index  n0. Note that the head of the stream has index 0. Beware>: passing a negative integer as the first argument will cause  an error. FThe F2 function takes two streams and returns a list of  corresponding pairs. GThe G function generalizes F. Rather than tupling = the functions, the elements are combined using the function ! passed as the first argument to G. HThe H function is the inverse of the F function. IThe I/ function breaks a stream of characters into a 7 stream of words, which were delimited by white space. JThe J% function is an inverse operation to I. It % joins words with separating spaces. KThe K4 function breaks a stream of characters into a list @ of strings at newline characters. The resulting strings do not  contain newlines. LThe L% function is an inverse operation to K. It = joins lines, after appending a terminating newline to each. 6 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLtuvwx1 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL1*2./01!"#$%& '5+,364-789:;<=>?@ABCDEFGHIJKL()5 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLtuvwxportable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered MOption is effectively y with a better instance of , built off of an underlying _  instead of an underlying F. Ideally, this type would not exist at all and we would just fix the  intance of y P-Provide a Semigroup for an arbitrary Monoid. SUse M (S a) -- to get the behavior of  VUse M (V a) -- to get the behavior of  `An associative operation.  (a <> b) <> c = a <> (b <> c) aReduce a non-empty list with <> XThe default definition should be sufficient, but this can be overridden for efficiency. bRepeat a value (n + 1) times.  7 times1p n a = a <> a <> ... <> a -- using <> n times UThe default definition uses peasant multiplication, exploiting associativity to only  require O(log n) uses of <>. cA generalization of   to an arbitrary _. ; May fail to terminate for some values in some semigroups. e@This lets you use a difference list of a Semigroup as a Monoid. BMNOPQRSTUVWXYZ[\]^_`abcdez{|}~/ MNOPQRSTUVWXYZ[\]^_`abcde/_`ab\]^YZ[VWXSTUPQR   MNOdec3MNOPQRSTUVWXYZ[\]^_`abcdez{|}~                       !"#$%&'()*+,-./01234567 89:;<=>?@ABCDEFGHIJKLMNOPPQRSTUVWWXYYZ[\]^_`abcdefghijklmn opqrstu vwxyz{|}~semigroups-0.8Data.SemigroupNumeric.Natural.InternalData.List.NonEmptyNumeric.Natural Data.MonoidLastFirst Data.ListcyclebasemconcatmappendmemptyMonoidgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductWhole toNatural unsafePredNatural runNaturalNonEmpty:|unfoldnonEmptyunconsheadtaillastinit<|conssortfromListtoListmapinitstailsinsertscanlscanrscanl1scanr1 intersperseiteratereverserepeattakedropsplitAt takeWhile dropWhilespanbreakfilter partitiongroupgroupBygroup1groupBy1 isPrefixOf!!zipzipWithunzipwordsunwordslinesunlinesOption getOption WrappedMonoid WrapMonoid unwrapMonoidgetLastgetFirstMaxgetMaxMingetMin Semigroup<>sconcattimes1pcycle1optiondiff$fWholeNatural $fWholeWord64 $fWholeWord32 $fWholeWord16 $fWholeWord8 $fWholeWord$fIntegralNatural $fEnumNatural $fRealNatural $fBitsNatural $fNumNatural $fReadNatural $fShowNatural Data.Foldablefoldl$fFoldableNonEmpty$fTraversableNonEmpty$fMonadNonEmpty$fApplicativeNonEmpty$fFunctorNonEmpty Data.MaybeMaybe$fSemigroupMap$fSemigroupIntMap$fSemigroupSet$fSemigroupIntSet$fSemigroupSeq$fMonoidOption$fSemigroupOption$fTraversableOption$fFoldableOption$fMonadFixOption$fMonadPlusOption$fAlternativeOption $fMonadOption$fApplicativeOption$fFunctorOption$fMonoidWrappedMonoid$fSemigroupWrappedMonoid$fSemigroupLast$fSemigroupFirst $fMonoidMax$fSemigroupMax $fMonoidMin$fSemigroupMin$fSemigroupNonEmpty$fSemigroupLast0$fSemigroupFirst0$fSemigroupProduct$fSemigroupSum$fSemigroupAny$fSemigroupAll$fSemigroupEndo$fSemigroupDual$fSemigroup(,,,,)$fSemigroup(,,,)$fSemigroup(,,)$fSemigroup(,)$fSemigroupEither$fSemigroupMaybe $fSemigroup[]$fSemigroup(->) $fSemigroup()