В Mon, 2 Jan 2012 10:45:18 +0100 Yves Parès пишет: Prelude> lines "string1\nstring2\r\nstring3\nstring4" ["string1","string2\r","string3","string4"]

Doesn't the function "lines" handle different line-endings? (In the Prelude and in Data.List)

If not, doing this with parsec would be easy (yet maybe slightly overkill...)

2012/1/2 max

...

I want to write a function whose behavior is as follows:

foo "string1\nstring2\r\nstring3\nstring4" = ["string1", "string2\r\nstring3", "string4"]

Note the sequence "\r\n", which is ignored. How can I do this?

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

Doesn't the function "lines" handle different line-endings? (In the Prelude and in Data.List) It does not ignore "\r\n".

Cheers, Simon

В Mon, 02 Jan 2012 11:12:49 +0000 Jon Fairbairn пишет:

max writes:

...

I want to write a function whose behavior is as follows:

foo "string1\nstring2\r\nstring3\nstring4" = ["string1", "string2\r\nstring3", "string4"]

Note the sequence "\r\n", which is ignored. How can I do this?

cabal install split

then do something like

import Data.List (groupBy) import Data.List.Split (splitOn)

rn '\r' '\n' = True rn _ _ = False

required_function = fmap concat . splitOn ["\n"] . groupBy rn

(though that might be an abuse of groupBy)

This is the simplest solution of the proposed, in my opinion. Thank you very much.

On Mon, Jan 2, 2012 at 5:52 PM, Felipe Almeida Lessa wrote:

On Mon, Jan 2, 2012 at 10:12 AM, max wrote:

...

This is the simplest solution of the proposed, in my opinion. Thank you very much.

Better yet, don't use String and use Text.  Then you just need T.splitOn "\r\n" [1].

That is actually the opposite of what the OP wants, however it's interesting that Text has a function like that and not the String functions in the standard library. -- Anupam

On 02/01/2012 11:12, Jon Fairbairn wrote:

max writes:

...

I want to write a function whose behavior is as follows:

foo "string1\nstring2\r\nstring3\nstring4" = ["string1", "string2\r\nstring3", "string4"]

Note the sequence "\r\n", which is ignored. How can I do this? cabal install split

then do something like

import Data.List (groupBy) import Data.List.Split (splitOn)

rn '\r' '\n' = True rn _ _ = False

required_function = fmap concat . splitOn ["\n"] . groupBy rn

(though that might be an abuse of groupBy)

Sadly, it turns out that not only is this an abuse of groupBy, but it has (I think) a subtle bug as a result. I was inspired by this to try some other groupBy stuff, and it didn't work. After scratching my head a bit, I tried the following... Prelude> import Data.List Prelude Data.List> groupBy (<) [1,2,3,2,1,2,3,2,1] [[1,2,3,2],[1,2,3,2],[1]] That wasn't exactly the result I was expecting :-( Explanation (best guess) - the function passed to groupBy, according to the docs, is meant to test whether two values are 'equal'. I'm guessing the assumption is that the function will effectively treat values as belonging to equivalence classes. That implies some rules such as... (a == a) reflexivity : (a == b) => (b == a) transitivity : (a == b) && (b == c) => (a == c) I'm not quite certain I got those names right, and I can't remember the name of the first rule at all, sorry. The third rule is probably to blame here. By the rules, groupBy doesn't need to compare adjacent items. When it starts a new group, it seems to always use the first item in that new group until it finds a mismatch. In my test, that means it's always comparing with 1 - the second 2 is included in each group because although (3 < 2) is False, groupBy isn't testing that - it's testing (1 < 2). In the context of this \r\n test function, this behaviour will I guess result in \r\n\n being combined into one group. The second \n will therefore not be seen as a valid splitting point. Personally, I think this is a tad disappointing. Given that groupBy cannot check or enforce that it's test respects equivalence classes, it should ideally give results that make as much sense as possible either way. That said, even if the test was always given adjacent elements, there's still room for a different order of processing the list (left-to-right or right-to-left) to give different results - and in any case, maybe it's more efficient the way it is.

Le Wed, 04 Jan 2012 17:49:15 +0000, Steve Horne a écrit :

On 04/01/2012 16:47, Steve Horne wrote:

...

(a == a) reflexivity : (a == b) => (b == a) transitivity : (a == b) && (b == c) => (a == c)

Oops - that's...

reflexivity : (a == a) symmetry : (a == b) => (b == a) transitivity : (a == b) && (b == c) => (a == c)

An equivalence relation is a relation that meets all these conditions.

I prefer to use "transymmetry" (although I guess it is not a regular word): reflexivity: a ≃ a transymmetry: ∀ a b. b≃a ⇒ ∀ c. c≃a ⇒ b≃c so I only have 2 rules. transymmetry is trivially derived from transitivity and symmetry. symmetry is trivially derived from reflexivity and transymmetry. transitivity is trivially derived from symmetry and transymmetry (and thus from transymmetry and reflexivity)

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

Steve Horne writes:

On 02/01/2012 11:12, Jon Fairbairn wrote:

...

max writes:

...

I want to write a function whose behavior is as follows:

foo "string1\nstring2\r\nstring3\nstring4" = ["string1", "string2\r\nstring3", "string4"]

Note the sequence "\r\n", which is ignored. How can I do this? cabal install split

then do something like

import Data.List (groupBy) import Data.List.Split (splitOn)

rn '\r' '\n' = True rn _ _ = False

required_function = fmap concat . splitOn ["\n"] . groupBy rn

(though that might be an abuse of groupBy)

Sadly, it turns out that not only is this an abuse of groupBy, but it has (I think) a subtle bug as a result.

It does indeed. Thanks. That was pretty much what I feared.

Explanation (best guess) - the function passed to groupBy, according to the docs, is meant to test whether two values are 'equal'. I'm guessing the assumption is that the function will effectively treat values as belonging to equivalence classes. That implies some rules such as...

Right. This issue has come up from time to time since groupBy was first written, and someone pops up to justify the present behaviour, but I can never remember why.

In the context of this \r\n test function, this behaviour will I guess result in \r\n\n being combined into one group. The second \n will therefore not be seen as a valid splitting point.

Correct. In my defence, I did say “do something like” :-)

Personally, I think this is a tad disappointing. Given that groupBy cannot check or enforce that it's test respects equivalence classes, it should ideally give results that make as much sense as possible either way. That said, even if the test was always given adjacent elements, there's still room for a different order of processing the list (left-to-right or right-to-left) to give different results - and in any case, maybe it's more efficient the way it is.

Looking back at the libraries list, I get the impression that there was a suggestion to change the behaviour of groupBy, but it doesn’t seem to have happened. -- Jón Fairbairn Jon.Fairbairn@cl.cam.ac.uk http://www.chaos.org.uk/~jf/Stuff-I-dont-want.html (updated 2010-09-14)

On Thu, Jan 5, 2012 at 05:57, Steve Horne wrote:

-- groupCut - Similar to groupBy, but where groupBy assumes an equivalence relation, -- groupCut takes a function that indicates where to cut. The two parameters to this -- function are always adjacent items from the list, and if the function returns True, -- a cut is done between the two items.

span/break? -- brandon s allbery allbery.b@gmail.com wandering unix systems administrator (available) (412) 475-9364 vm/sms

Steve Horne writes:

On 05/01/2012 11:09, Brandon Allbery wrote:

...

On Thu, Jan 5, 2012 at 05:57, Steve Horne mailto:sh006d3592@blueyonder.co.uk> wrote:

-- groupCut - Similar to groupBy, but where groupBy assumes an equivalence relation, -- groupCut takes a function that indicates where to cut. The two parameters to this -- function are always adjacent items from the list, and if the function returns True, -- a cut is done between the two items.

span/break?

Using those, the test function won't always be passed two *adjacent* elements from the list. After all, they're based on takeWhile and dropWhile, which take unary functions, meaning an element has already been curried in (the starting element of the group).

That's probably how the current groupBy is implemented - the approach that assumes an equivalence relation, giving unexpected results when the By function isn't an equivalence relation.

groupBy is currently implemented using span. It strikes me that we ought to specify some properties for what we want. Start by defining: pairwiseInOrderBy p l = all (uncurry p) (l `zip` drop 1 l) giving all (pairwiseInOrderBy p) (groupCut p l) and we would want concat (groupCut p l) == l (all modulo nontermination side conditions). Anything else? -- Jón Fairbairn Jon.Fairbairn@cl.cam.ac.uk

Am 05.01.2012 11:57, schrieb Steve Horne: [...]

groupCut :: (x -> x -> Bool) -> [x] -> [[x]] [...]

How about a break function that respects an escape character (1. arg) (and drops the delimiter - 2. arg) and use this function for unfolding? import Data.List break' :: (a -> Bool) -> (a -> Bool) -> [a] -> ([a], [a]) break' e p l = case l of [] -> (l, []) c : r | p c -> ([], r) | e c -> case r of [] -> (l, []) d : t -> let (f, s) = break' e p t in (c : d : f, s) | otherwise -> let (f, s) = break' e p r in (c : f, s) split' :: (a -> Bool) -> (a -> Bool) -> [a] -> [[a]] split' e p = unfoldr $ \ l -> if null l then Nothing else Just $ break' e p l *Main> split' (== '\r') (== '\n') "string1\nstring2\r\nstring3\nstring4" ["string1","string2\r\nstring3","string4"] C.

Am 05.01.2012 13:04, schrieb Steve Horne: [...]

I was going to accuse you of cheating - who says there's a spare value to use? - but you seem to be using Maybe, so well played.

You're also using unfoldr, which I really must play with a bit - I don't really have a feel for how unfolding works ATM.

You may prefer another variant of unfoldr (without Maybe): unfoldr' :: ([b] -> (a, [b])) -> [b] -> [a] unfoldr' f l = if null l then [] else let (a, r) = f l in a : unfoldr' f r split' :: (a -> Bool) -> (a -> Bool) -> [a] -> [[a]] split' e p = unfoldr' $ break' e p C. P.S. my break' function fails for "\r\r\n" (as the first char escapes the second and the second no longer the third)