Îõ³h)'Ø%ÝÝ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\1.0.0 Trustworthy6;?ÀÂÌ×ÚÜãëï%=Ê neononempty!A list with one or more elements. neononempty0Construct a NonEmpty from an element and a list. neononempty0Construct a NonEmpty list from a single element. neononempty Construct a  from an element and a list. neononemptyñA non empty thing. Useful as a syntactically lightweight type annotation, especially when using OverloadedLists::set -XOverloadedLists[(), ()]À ¢@ Ambiguous type variable ˜@a0™@ arising from a use of ˜@print™@< prevents the constraint ˜@(Show a0)™@ from being solved.aNonEmpty [(), ()][(),()] neononemptyConverts base's ] to a  neononempty Converts a  to base's  neononemptyÒConverts a normal list to a NonEmpty list, given the list has at least one element neononempty Converts a  list to a normal list  neononempty$Number of elements in NonEmpty list.  neononempty1Extract the first element of the nonempty stream.  neononempty7Extract the possibly-empty tail of the nonempty stream.  neononempty0Extract the last element of the nonempty stream.  neononemptyÂExtract everything except the last element of the nonempty stream. neononempty*Prepend an element to the nonempty stream. neononemptyÛProduces the first element of the nonempty stream, and a stream of the remaining elements. neononempty3Append an element to the back of a nonempty stream. neononemptyÂProduces all elements up to the last element, and the last element neononemptyDual of foldr, see ^. neononemptySort a nonempty stream. neononemptyReverse a nonempty stream. neononemptyÒProduces all the prefixes of a stream, starting with the shortest. The result is É because the result always contains the empty list as the first element. inits [1,2,3][[], [1], [1,2], [1,2,3]] inits [1] [[], [1]]inits [][[]] neononemptyÔProduces all the nonempty prefixes of a nonempty stream, starting with the shortest.inits1 [1,2,3][[1], [1,2], [1,2,3]] inits1 [1][[1]] neononemptyÑProduces all the suffixes of a stream, starting with the longest. The result is É because the result always contains the empty list as the first element. tails [1,2,3][[1, 2, 3], [2, 3], [3], []] tails [1] [[1], []]tails [][[]] neononemptyÓProduces all the nonempty suffixes of a nonempty stream, starting with the longest.tails1 [1,2,3][[1, 2, 3], [2, 3], [3]] tails1 [1][[1]] neononempty A monomorphic version of <> for .append [1] [2, 3] [1, 2, 3] neononemptyAppend a list at the end of a .appendList [1, 2, 3] [] [1, 2, 3]appendList [1, 2, 3] [4, 5][1, 2, 3, 4, 5] neononempty!Prepend a list to the front of a .prependList [] [1, 2, 3] [1, 2, 3]#prependList [negate 1, 0] [1, 2, 3][-1, 0, 1, 2, 3] neononempty&Map a function over a NonEmpty stream. neononempty Produces a Ñ which alternates between elementes of the input list, and the supplied element.intersperse 0 [1, 2, 3])[1, 0, 2, 0, 3]intersperse 0 [1][1] neononempty4Left-associative fold, lazy in the accumulator. See _. neononempty6Left-associative fold, strict in the accumulator. See `.  neononempty6Left-associative fold, strict in the accumulator. See `.! neononemptyÜscanl is similar to foldl, but returns a stream of successive reduced values from the left:scanl (+) 1 [20, 300, 4000][1,21,321,4321]" neononemptyA strict version of !.# neononemptyÁscanl1 is a variant of scanl that has no starting value argument: "scanl1 f [x1, x2, ...] == [x1, x1 f x2, x1 f (x2 f x3), ...] $ neononemptyŒRight-to-left dual of scanl. Note that the order of parameters on the accumulating function are reversed compared to scanl. Also note that $head (scanr f z xs) == foldr f z xs scanr (+) 0 [1..4] [10,9,7,4,0]scanr (+) 42 [][42]scanr (-) 100 [1..4][98,-97,99,-96,100]% neononemptyÁscanr1 is a variant of scanr that has no starting value argument.scanr1 (+) [1..4] [10,9,7,4] scanr1 (+) [][]scanr1 (-) [1..4] [-2,3,-1,4]& neononempty,transpose for NonEmpty, behaves the same as a>. The rows/columns need not be the same length, in which case transpose . transpose /= id ' neononemptyBehaves the same as b( neononempty¼Sort a list on a projection of its elements. Projects once, then sorts, then un-projects. This is useful when the projection function is expensive. If it's not, you should probably use ).) neononempty§Sort a list on a projection of its elements. Projects during comparison. This is useful when the projection function is cheap. If it's not, you should probably use (.* neononemptyÎiterate f x produces the infinite sequence of repeated applications of f to x. $iterate f x = [x, f x, f (f x), ..] + neononemptyÆrepeat x returns a constant stream, where all elements are equal to x., neononempty/cycle xs returns the infinite repetition of xs: +cycle [1, 2, 3] == [1, 2, 3, 1, 2, 3, ...] - neononempty°insert x xs inserts x into the last position in xs where it is still less than or equal to the next element. If the list is sorted beforehand, the result will also be sorted.. neononempty&some1 x sequences x one or more times./ neononempty-take n xs returns the first n elements of xs.0 neononemptyÇdrop n xs drops the first n elements from the front of the sequence xs.1 neononempty‚splitAt n xs returns a pair consisting of the prefix of xs of length n and the remaining stream immediately following this prefix.1 n xs == (/ n xs, 0 n xs)2 neononemptyÈProduces the longest prefix of the stream for which the predicate holds.3 neononemptyÂdropWhile p xs produces the suffix remaining after takeWhile p xs.4 neononemptyçspan p xs returns the longest prefix of xs that satisfies p, together with the remainder of the stream.4 p xs == (2 p xs, 3 p xs)5 neononempty(break p is equivalent to span (not . p).6 neononemptyÊRemoves any elements of a nonempty stream that do not satisfy a predicate.7 neononempty÷Produces a pair of lists, the first of elements that satisfy the given predicate, the second of elements that did not. 7 p xs == (6 p xs, 6 (not . p) xs) 8 neononemptyºTakes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements.group "Mississippi"+["M", "i", "ss", "i", "ss", "i", "pp", "i"]9 neononempty Similar to 8á, but sorts the input first so that each equivalence class has, at most, one list in the output.: neononempty Similar to 86, but uses the provided equality predicate instead of c.; neononempty Similar to :á, but sorts the input first so that each equivalence class has, at most, one list in the output.< neononempty Similar to 8?, but uses the provided projection when comparing for equality.= neononempty Similar to <á, but sorts the input first so that each equivalence class has, at most, one list in the output.> neononempty Similar to dÝ, but uses the knowledge that its input is non-empty to produce guaranteed non-empty output.? neononempty Similar to >á, but sorts the input first so that each equivalence class has, at most, one list in the output.@ neononempty Similar to >6, but uses the provided equality predicate instead of c.A neononempty Similar to 8á, but sorts the input first so that each equivalence class has, at most, one list in the output.B neononempty Similar to >?, but uses the provided projection when comparing for equality.C neononempty Similar to Bà, but sorts the list first so that each equivalence class has, at most, one list in the output.D neononempty=Returns True if the first argument is a prefix of the second.$isPrefixOf [1, 2, 3] [1, 2, 3, 4, 5]TrueisPrefixOf "abc" "defghi"FalseisPrefixOf "abc" ""FalseE neononempty€Removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means essenceä.) It is a special case of nubBy, which allows the programmer to supply their own inequality test.F neononemptyäBehaves just like nub, except it uses a user-supplied equality predicate instead of the overloaded c function.G neononemptyóxs !! n returns the element of the stream xs at index n, if present. Note that the head of the stream has index 0.H neononempty\mathcal{O}(\min(m,n))Â. Takes two streams and produces a stream of corresponding pairs.zip [1, 2] ['a', 'b'][(1, 'a'),(2, 'b')]I neononempty\mathcal{O}(\min(m,n))Ù. Generalises zip by zipping with the provided function, instead of a tupling function.Ê  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIÊ  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIG9 å      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a`b`cd`ce`b)`b*fgh`b;éneononempty-1.0.0-inplaceData.List.NeoNonEmpty neononemptyNonEmpty:| singletonfromCons aNonEmpty fromNonEmpty toNonEmptyfromListtoListlengthheadtaillastinitconsunconssnocunsnocunfoldrsortreverseinitsinits1tailstails1append appendList prependListmap interspersefoldl1foldl1'foldr1scanlscanl'scanl1scanrscanr1 transposesortBysortOnsortWithiteraterepeatcycleinsertsome1takedropsplitAt takeWhile dropWhilespanbreakfilter partitiongroupgroupAllgroupBy groupAllBy groupWith groupAllWithgroup1 groupAll1groupBy1 groupAllBy1 groupWith1 groupAllWith1 isPrefixOfnubnubBy!?zipzipWith$fReadNonEmpty$fShowNonEmpty$fIsListNonEmpty$fGenericNonEmpty$fGeneric1TYPENonEmpty$fDataNonEmpty$fApplicativeNonEmpty$fFunctorNonEmpty$fMonadFixNonEmpty$fMonadZipNonEmpty$fFoldableNonEmpty $fEq1NonEmpty$fOrd1NonEmpty$fRead1NonEmpty$fShow1NonEmpty$fMonadNonEmpty $fEqNonEmpty $fOrdNonEmpty$fSemigroupNonEmptybaseGHC.Base Data.OldList Data.Foldablefoldlfoldl'ghc-prim GHC.Classes==