Îõ³h&#[":      !"#$%&'()*+,-./0123456789 Safe-Inferred!§1StreamAn infinite sequence.Beware#: If you use any function from the  Eq  or  Ord à class to compare two equal streams, these functions will diverge.StreamThe  <:> % operator is an infix version of the  constructor.Stream*Extract the first element of the sequence.Stream6Extract the sequence following the head of the stream.StreamThe  function takes a stream xs) and returns all the finite prefixes of xs.Note that this  is lazier then Data.List.inits: inits _|_ = [] ::: _|_ while for Data.List.inits: inits _|_ = _|_StreamThe  function takes a stream xs" and returns all the suffixes of xs.Stream;Apply a function uniformly over all elements of a sequence.Stream y xs1 creates an alternating stream of elements from xs and y. StreamInterleave two Streams xs and ys', alternating elements from each list. 9[x1,x2,...] `interleave` [y1,y2,...] == [x1,y1,x2,y2,...] Stream 3 yields a stream of successive reduced values from: ?scan f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Streamscan' is a strict scan. Stream  is a variant of  % that has no starting value argument: -scan1 f [x1, x2, ...] == [x1, x1 `f` x2, ...] Streamscan1'- is a strict scan that has no starting value.Stream3 computes the transposition of a stream of streams.Stream f xÆ function produces the infinite sequence of repeated applications of f to x. #iterate f x = [x, f x, f (f x), ..]StreamThe “ function adds a list as a prefix to an existing stream. If the list is infinite, it is converted to a Stream and the second argument is ignored.Stream x= returns a constant stream, where all elements are equal to x.Stream xs$ returns the infinite repetition of xs: :cycle [1,2,3] = Cons 1 (Cons 2 (Cons 3 (Cons 1 (Cons 2 ...StreamòThe unfold function is similar to the unfold for lists. Note there is no base case: all streams must be infinite.Stream n xs returns the first n elements of xs.BewareÈ: passing a negative integer as the first argument will cause an error.Stream n xs drops the first n) elements off the front of the sequence xs.BewareÈ: passing a negative integer as the first argument will cause an error.StreamThe  function takes an integer n and a stream xs1 and returns a pair consisting of the prefix of xs of length n< and the remaining stream immediately following this prefix.BewareÈ: passing a negative integer as the first argument will cause an error.Stream p xs+ returns the longest prefix of the stream xs for which the predicate p holds.Stream p xs% returns the suffix remaining after  p xs.Beware0: this function may diverge if every element of xs satisfies p, e.g. dropWhile even (repeat 0) will loop.Stream p xs returns the longest prefix of xs that satisfies p,, together with the remainder of the stream.Beware0: this function may diverge if every element of xs satisfies p, e.g. span even (repeat 0) will loop.StreamThe  p function is equivalent to  not . p.Beware3: this function may diverge for the same reason as span.Stream p xs, removes any elements from xs that do not satisfy p.Beware7: this function may diverge if there is no element of xs that satisfies p, e.g. filter odd (repeat 0) will loop.StreamThe  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.BewareÃ: One of the elements of the tuple may be undefined. For example, +fst (partition even (repeat 0)) == repeat 0; on the other hand snd (partition even (repeat 0)) is undefined.StreamThe Ù function takes a stream and returns a stream of 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, ôgroup $ cycle "Mississippi" = "M" ::: "i" ::: "ss" ::: "i" ::: "ss" ::: "i" ::: "pp" ::: "i" ::: "M" ::: "i" ::: ...StreamThe isPrefix function returns True2 if the first argument is a prefix of the second.Streamxs !! n# returns the element of the stream xs at index n/. Note that the head of the stream has index 0.BewareÈ: passing a negative integer as the first argument will cause an error. StreamThe  Ù function returns the index of the first element in the given stream which is equal (by :) to the query element,Beware:   x xs* will diverge if none of the elements of xs equal x.!StreamThe ! function extends  Û, by returning the indices of all elements equal to the query element, in ascending order.Beware: ! x xs will diverge if any suffix of xs does not contain x."StreamThe "€ function takes a predicate and a stream and returns the index of the first element in the stream that satisfies the predicate,Beware: " p xs* will diverge if none of the elements of xs satisfy p.#StreamThe # function extends "Ú, by returning the indices of all elements satisfying the predicate, in ascending order.Beware: # p xs4 will diverge if all the elements of any suffix of xs fails to satisfy p.$StreamThe $‰ function takes two streams and returns the stream of pairs obtained by pairing elements at the same position in both argument streams.%StreamThe % function behaves as the $' function, but works on three streams.&StreamThe & function generalizes $ô. Rather than tupling the functions, the elements are combined using the function passed as the first argument to &.'StreamThe ' behaves as &# but takes three stream arguments.(StreamThe ( function is similar to the ;. function defined in Data.Traversable. Since Streams are not < in general, there is no =ù instance for streams. They do support a similar notion that only requires the outer type constructor to be functorial.)StreamThe ) function is the inverse of the $ function.*StreamThe * function is the inverse of the $ function.+StreamThe +å function breaks a stream of characters into a stream of words, which were delimited by white space.Beware: if the stream of characters xs6 does not contain white space, accessing the tail of words xs will loop.,StreamThe ,% function is an inverse operation to +). It joins words with separating spaces.-StreamThe -† function breaks a stream of characters into a list of strings at newline characters. The resulting strings do not contain newlines.Beware: if the stream of characters xs= does not contain newline characters, accessing the tail of lines xs will loop..StreamThe .% function is an inverse operation to -Á. It joins lines, after appending a terminating newline to each./StreamThe /) converts a stream into an infinite list.0StreamThe 0( converts an infinite list to a stream.Beware-: Passing a finite list, will cause an error.1Stream–A Show instance for Streams that takes the right associativity into account and so doesn't put parenthesis around the tail of the Stream. Note that > returns an infinite ?.1  !"#$%&'()*+,-./01  !"#$&)%'*(+,-./055À      !"#$%&'()*+,-./0123456789:;<=>?@A?BC?@D?EF?GHÉStream-0.4.7.2-inplace Data.StreamStreamCons<:>headtailinitstailsmap intersperse interleavescanscan'scan1scan1' transposeiterateprefixrepeatcycleunfoldtakedropsplitAt takeWhile dropWhilespanbreakfilter partitiongroup isPrefixOf!! elemIndex elemIndices findIndex findIndiceszipzip3zipWithzipWith3 distributeunzipunzip3wordsunwordslinesunlinestoListfromList $fShowStream$fSerialStream$fCoArbitraryStream$fArbitraryStream $fMonadStream$fApplicativeStream$fFunctorStream $fEqStream $fOrdStreamghc-prim GHC.Classes==baseData.Traversable sequenceA Data.FoldableFoldable TraversableGHC.ShowshowGHC.BaseString