úέۨ=f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeNone9:;<=?DORT3Append two to make one..Prepend a value to a separated-like structure..Prepend a value to a separated-like structure. !Construction of separated values.#Construct a single separated value.Structures that have a tail.$Structures that have a head element.The  Separated1 type constructor, flipped.The  Separated type constructor, flipped.5A list of pairs of separator and value. Separated by a in values b5. There is one more value than there are separators.5A list of pairs of separator and value. Separated by a in values b>. There are an even number of separators as there are values.CThe isomorphism to a list of pairs of element and separator values.separated # emptySeparated[](separated # ('x' +: 6 +: emptySeparated) [('x',6)][] ^. separated[][(6, [])] ^. separated[6,[]] @The isomorphism to element values interspersed with a separator. separated1 # (singleSeparated 6)(6,[]),separated1 # (5 +: 'x' +: singleSeparated 6) (5,['x',6])!(6, emptySeparated) ^. separated1[6](5, 'x' +- 6) ^. separated1 [5,'x',6]!@The isomorphism to element values interspersed with a separator.pesarated # emptyPesarated[]('a', 'x' +- 6) ^. pesarated1 ['a',6,'x']('x' -: 6 -: emptyPesarated)['x',6]"@The isomorphism to element values interspersed with a separator.pesarated1 # singlePesarated 6(6,[]),pesarated1 # (8 -: 'x' -: singlePesarated 6) (8,['x',6])(6, empty) ^. pesarated1[6](5, 'x' -+ 6) ^. pesarated1 [5,'x',6]#-Alternate separated values e.g. `f ~ Parser`..parse (separatedBy (char ',') digit) "test" ""Right []8isLeft (parse (separatedBy (char ',') digit) "test" ",")True0parse (separatedBy (char ',') digit) "test" ",1"Right [',','1']:isLeft (parse (separatedBy (char ',') digit) "test" ",1,")True8parse (separatedBy (char ',') digit) "test" ",1,2,3,4,5"/Right [',','1',',','2',',','3',',','4',',','5']$-Alternate separated values e.g. `f ~ Parser`.8isLeft (parse (separatedBy1 (char ',') digit) "test" "")True0parse (separatedBy1 (char ',') digit) "test" "," Right [',']:isLeft (parse (separatedBy1 (char ',') digit) "test" ",1")True2parse (separatedBy1 (char ',') digit) "test" ",1,"Right [',','1',',']:parse (separatedBy1 (char ',') digit) "test" ",1,2,3,4,5,"3Right [',','1',',','2',',','3',',','4',',','5',',']%-Alternate separated values e.g. `f ~ Parser`..parse (pesaratedBy (char ',') digit) "test" ""Right []8isLeft (parse (pesaratedBy (char ',') digit) "test" ",")True0parse (separatedBy (char ',') digit) "test" ",1"Right [',','1']:isLeft (parse (pesaratedBy (char ',') digit) "test" ",1,")True8parse (pesaratedBy (char ',') digit) "test" ",1,2,3,4,5"/Right [',','1',',','2',',','3',',','4',',','5']&-Alternate separated values e.g. `f ~ Parser`.8isLeft (parse (pesaratedBy1 (char ',') digit) "test" "")True0parse (pesaratedBy1 (char ',') digit) "test" "," Right [',']:isLeft (parse (pesaratedBy1 (char ',') digit) "test" ",1")True2parse (pesaratedBy1 (char ',') digit) "test" ",1,"Right [',','1',',']:parse (pesaratedBy1 (char ',') digit) "test" ",1,2,3,4,5,"3Right [',','1',',','2',',','3',',','4',',','5',',']fGThe isomorphism that shuffles the elements and separators one position.shift # ([], 6)[6]shift # ([(5, 'x')], 6) [5,'x',6]singleSeparated 6 ^. shift([],6)((5 +: 'x' +: singleSeparated 6) ^. shift ([(5,'x')],6)(ÁApplies functions with separator values, using a zipping operation, appending elements. The identity operation is an infinite list of the emptySeparated element and the given separator value.hid -: [1,2] -: reverse -: [3,4] -: emptyPesarated <*> "def" -: [5,6,7] -: "abc" -: [8] -: emptyPesarated!["def",[1,2,5,6,7],"cba",[3,4,8]])XApplies functions with separator values, using a zipping operation, appending elements.hid -: [1,2] -: reverse -: [3,4] -: emptyPesarated <.> "def" -: [5,6,7] -: "abc" -: [8] -: emptyPesarated!["def",[1,2,5,6,7],"cba",[3,4,8]]* Map across a  Pesarated1 on the separator values.|fmap toUpper (set tailL (1 -: 'b' -: 2 -: 'c' -: empty) (singlePesarated 'z' :: Pesarated1 Int Char) :: Pesarated1 Int Char)['Z',1,'B',2,'C'])fmap id (x :: Pesarated1 Int String) == xOfmap (+1) (singlePesarated x :: Pesarated1 Char Int) == singlePesarated (x + 1).L('x' -: (6 :: Int) -: emptyPesarated) `mappend` ('y' -: 7 -: emptyPesarated) ['x',6,'y',7]/E('x' -: (6 :: Int) -: emptyPesarated) <> ('y' -: 7 -: emptyPesarated) ['x',6,'y',7]0(show (emptyPesarated :: Pesarated () ())"[]"*show ('x' -: (6 :: Int) -: emptyPesarated) "['x',6]"1ÁApplies functions with element values, using a zipping operation, appending separators. The identity operation is an infinite list of the emptySeparated separator and the given element value.K(emptySeparated :: Separated [Int] (String -> [String])) <*> emptySeparated[]b(\s -> [s, reverse s, drop 1 s]) -: [1,2] -: emptyPesarated <*> "abc" -: [3,4,5] -: emptyPesarated [["abc","cba","bc"],[1,2,3,4,5]]2XApplies functions with element values, using a zipping operation, appending separators.K(emptyPesarated :: Pesarated [Int] (String -> [String])) <.> emptyPesarated[]b(\s -> [s, reverse s, drop 1 s]) -: [1,2] -: emptyPesarated <.> "abc" -: [3,4,5] -: emptyPesarated [["abc","cba","bc"],[1,2,3,4,5]]3 Map across a  Pesarated on the element values.(fmap id (x :: Pesarated Int String) == xL\a b -> fmap (+1) (a -: b -: emptyPesarated) == (1+a) -: b -: emptyPesarated7:The isomorphism that swaps elements with their separators.swapped # emptyPesarated[]&swapped # ('x' -: 6 -: emptyPesarated)[6,'x']emptyPesarated ^. swapped[]'('x' -: 6 -: emptyPesarated) ^. swapped[6,'x']9ÁApplies functions with separator values, using a zipping operation, appending elements. The identity operation is an infinite list of the emptySeparated element and the given separator value.Y[1,2] +: reverse +: [3,4] +: emptySeparated <*> [5,6,7] +: "abc" +: [8] +: emptySeparated[[1,2,5,6,7],"cba",[3,4,8]]:XApplies functions with separator values, using a zipping operation, appending elements.Y[1,2] +: reverse +: [3,4] +: emptySeparated <.> [5,6,7] +: "abc" +: [8] +: emptySeparated[[1,2,5,6,7],"cba",[3,4,8]]; Map across a  Separated1 on the separator values.kfmap (+1) (set tailL (1 +: 'b' +: 2 +: 'c' +: emptySeparated) (singleSeparated 'a' :: Separated1 Char Int))['a',2,'b',3,'c'])fmap id (x :: Separated1 Int String) == xIfmap (+1) (singleSeparated x :: Separated1 Char Int) == singleSeparated x?L('x' +: (6 :: Int) +: emptySeparated) `mappend` ('y' +: 7 +: emptySeparated) ['x',6,'y',7]@E('x' +: (6 :: Int) +: emptySeparated) <> ('y' +: 7 +: emptySeparated) ['x',6,'y',7]A(show (emptySeparated :: Separated () ())"[]"*show ('x' +: (6 :: Int) +: emptySeparated) "['x',6]"BÁApplies functions with element values, using a zipping operation, appending separators. The identity operation is an infinite list of the emptySeparated separator and the given element value.K(emptySeparated :: Separated [Int] (String -> [String])) <*> emptySeparated[]b[1,2] +: (\s -> [s, reverse s, drop 1 s]) +: emptySeparated <*> [3,4,5] +: "abc" +: emptySeparated [[1,2,3,4,5],["abc","cba","bc"]]CXApplies functions with element values, using a zipping operation, appending separators.K(emptySeparated :: Separated [Int] (String -> [String])) <.> emptySeparated[]b[1,2] +: (\s -> [s, reverse s, drop 1 s]) +: emptySeparated <.> [3,4,5] +: "abc" +: emptySeparated [[1,2,3,4,5],["abc","cba","bc"]]D Map across a  Separated on the element values.(fmap id (x :: Separated Int String) == xL\a b -> fmap (+1) (a +: b +: emptySeparated) == a +: (1+b) +: emptySeparatedH:The isomorphism that swaps elements with their separators.swapped # emptySeparated[]&swapped # ('x' +: 6 +: emptySeparated)[6,'x']emptySeparated ^. swapped[]'('x' +: 6 +: emptySeparated) ^. swapped[6,'x']IgAppend a list of pairs of separator and element values to element values interspersed with a separator.V(singleSeparated 7 :: Separated1 Int Char) <++> (emptySeparated :: Separated Char Int)[7]b(singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int) [6,'x',7]i'w' +: (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int) ['w',6,'x',7]JgAppend element values interspersed with a separator to a list of pairs of separator and element values.V(emptySeparated :: Separated Int Char) <++> (singleSeparated 7 :: Separated1 Int Char)[7]b(emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char) [6,'x',7]i'w' +: (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char) ['w',6,'x',7]K`Append two lists of separated values to produce a list of pairs of separator and element values.\(singleSeparated 7 :: Separated1 Int Char) <++> (singleSeparated 'a' :: Separated1 Char Int)[7,'a']a/ +: (singleSeparated 7 :: Separated1 Int Char)  ++ (singleSeparated b :: Separated1 Char Int) [a,7,b]Ra +: (b :: Separated Int Int) == a +: b -- (a +: (b <++> c)) == ((a +: b) <++> c)POne element and one separator.$(7 -+ "abc") :: Pesarated String Int [7,"abc"]27 -: "abc" -: (8 -+ "def") :: Pesarated String Int[7,"abc",8,"def"]QOne element and one separator.$(7 +- "abc") :: Separated Int String [7,"abc"]27 +: "abc" +: (8 +- "def") :: Separated Int String[7,"abc",8,"def"]R2Zero element values interspersed with one element.*(singlePesarated 4 :: Pesarated1 Char Int)[4]F(singlePesarated x :: Pesarated1 Int Char) ^. tailL == emptyPesaratedS2Zero element values interspersed with one element.*(singleSeparated 4 :: Separated1 Int Char)[4]F(singleSeparated x :: Separated1 Int Char) ^. tailL == emptySeparatedTA lens on the tail.[(d -: e -: (singlePesarated x :: Pesarated1 Char Int)) ^. tailL == e -: x -: emptyPesaratedUA lens on the tail.[(d +: e +: (singleSeparated x :: Separated1 Int Char)) ^. tailL == e +: x +: emptySeparatedV"A lens on the first element value.3(singlePesarated 7 :: Pesarated1 Char Int) ^. headL7A(singlePesarated x :: Pesarated1 Char Int) ^. headL == (x :: Int)W"A lens on the first element value.3(singleSeparated 7 :: Separated1 Int Char) ^. headL7A(singleSeparated x :: Separated1 Int Char) ^. headL == (x :: Int)`  !"#$%&ghijf'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWklm'  !"#$%&' !"  #$%&M   !"#$%&ghijf'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWklm55 5 9 n      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl&separated-0.2.0-6bp3vmQ1QIZ6X0pjqTTvPbData.SeparatedAppends<++> PesaratedConsPesaratedConsFPesaratedConsG-: SeparatedConsSeparatedConsFSeparatedConsG+: Construct+--+emptysprinklePesarated1SinglesinglePesaratedSeparated1SinglesingleSeparatedHasTailtailLHasHeadheadL Pesarated1 Pesarated Separated1 Separated separated separated1 pesarated pesarated1 separatedBy separatedBy1 pesaratedBy pesaratedBy1$fShowPesarated1$fApplicativePesarated1$fApplyPesarated1$fFunctorPesarated1$fBitraversablePesarated1$fBifoldablePesarated1$fBifunctorPesarated1$fMonoidPesarated$fSemigroupPesarated$fShowPesarated$fApplicativePesarated$fApplyPesarated$fFunctorPesarated$fBitraversablePesarated$fBifoldablePesarated$fBifunctorPesarated$fSwappedPesarated$fShowSeparated1$fApplicativeSeparated1$fApplySeparated1$fFunctorSeparated1$fBitraversableSeparated1$fBifoldableSeparated1$fBifunctorSeparated1$fMonoidSeparated$fSemigroupSeparated$fShowSeparated$fApplicativeSeparated$fApplySeparated$fFunctorSeparated$fBitraversableSeparated$fBifoldableSeparated$fBifunctorSeparated$fSwappedSeparated&$fAppendsSeparated1SeparatedSeparated1&$fAppendsSeparatedSeparated1Separated1&$fAppendsSeparated1Separated1Separated"$fPesaratedConsPesarated1Pesarated"$fPesaratedConsPesaratedPesarated1"$fSeparatedConsSeparatedSeparated1"$fSeparatedConsSeparated1Separated$fConstructPesarated$fConstructSeparated$fPesarated1SinglePesarated1$fSeparated1SingleSeparated1/$fHasTailPesarated1Pesarated1PesaratedPesarated/$fHasTailSeparated1Separated1SeparatedSeparated$fHasHeadPesarated1Pesarated1tt$fHasHeadSeparated1Separated1aa $fEqSeparated$fOrdSeparated$fEqSeparated1$fOrdSeparated1 $fEqPesarated$fOrdPesarated$fEqPesarated1$fOrdPesarated1$fWrappedSeparated$fRewrappedSeparatedt$fWrappedPesarated$fRewrappedPesaratedt$fWrappedPesarated1$fRewrappedPesarated1tshift showSeparated separatedAp separated1Ap pesarated1ApD:R:UnwrappedSeparatedD:R:UnwrappedPesaratedD:R:UnwrappedPesarated1