Comments on: one line binary reader in haskell

By: huh. google knows about me now, go figure. « tehgeekmeister’s blog

huh. google knows about me now, go figure. « tehgeekmeister’s blog — Mon, 14 Jan 2008 06:08:15 +0000

[...] — tehgeekmeister @ 10:08 pm apparently submitting that last post to reddit has gotten my previous post to be in the first page of google results for “binary reader“. cool, i’m fine [...]

By: tehgeekmeister

tehgeekmeister — Sun, 13 Jan 2008 02:30:19 +0000

Mike: that’s true, i figured there was probably a way to get around that. my head isn’t alway so clear when i’m going thru these exercises, and i’ve not done that much programming, it being a hobby and certainly not my job. that being said, i’m glad to know where the problem in my algorithm was! good point about using foldl’, too.

Paczesiowa: that’s very concise and elegant, but i really don’t like that it would successfully parse non-binary strings. of course, in the case where the string has already been parsed (exactly what i’m doing) that’s not a problem. that aside, i think i like that version the very best of all the versions i’ve seen.

By: Paczesiowa

Paczesiowa — Sun, 13 Jan 2008 02:17:08 +0000

import Data.Char
readBin = foldl (\a b -> 2*a + digitToInt b) 0

By: Mike Laiosa

Mike Laiosa — Sat, 12 Jan 2008 10:01:31 +0000

As you might be able to glean from comment #2, the (`div` 2) in your version is unneeded if you change the fold around a bit:

readBin = foldl (\x y -> x*2 + y) 0 . map (\c -> case c of {’0′ -> 0; ‘1′ -> 1; _ -> error “Input is not a binary string.”})

And I would be inclined to put the body of the map into the fold too:

readBin = foldl (\x y -> x*2 + case y of {‘0′ -> 0; ‘1′-> 1;_ -> error “Input is not a binary string”}) 0

You should also use foldl’ from Data.List to cut down on lazyness. (That buys you nothing – readBin always needs to read the whole list). As cool as the one line thing is, I’d really be inclined to do it in a couple more, since I don’t care for either one-line case expressions or lambdas.

By: tehgeekmeister

tehgeekmeister — Sat, 12 Jan 2008 05:09:29 +0000

Meneer: your first fold version is the one i prefer for readability and my purposes of all your versions (i’m merely converting already parsed binary strings in the course of going thru http://halogen.note.amherst.edu/~jdtang/scheme_in_48/tutorial/overview.html, so there’s really no need for any error reporting at all, i only added it for the purposes of the post.). also, a maybe based version is certainly more elegant than throwing an error, but i didn’t know how to do that in a one-liner, so thanks for showing me a few versions.

also, i must admit that the version in the reddit comment is beautifully succint. i’m glad i posted this so that i could see some better versions.

By: Meneer R

Meneer R — Sat, 12 Jan 2008 03:39:08 +0000

On reddit i found even a pretties version!

readBin = foldM (\a d -> (a*2 +) elemIndex d “01″) 0

Autheur: PjdePort
Link: http://programming.reddit.com/info/6597u/comments/c02vlf9

By: Meneer R

Meneer R — Sat, 12 Jan 2008 03:32:59 +0000

The most readable version, unfortunately it works in reverse:

rBin (‘0′:xs) = 0 + 2 * rBin xs
rBin (‘1′:xs) = 1 + 2 * rBin xs
rBin [] = 0

readBin1 = rBin . reverse

If you don’t care for the sort of error reporting, the shortest code I could come up with is:

readBin2 = foldl (\ x y -> fromJust(elemIndex y “01″) + 2*x ) 0

This will give you an pattern-match-failure with fromJust with badly formatted string. If you want a nicer error message:

readBin4 = foldl (\ x y -> fromMaybe (error “Input is not binary”) (elemIndex y “01″) + 2*x ) 0

Still a pretty oneliner. But not points-free. Let’s make it points-free!

readBin5 = flip foldl 0 $ flip $ (+) . (*2) . (fromMaybe (error “Input is not binary”)) . (flip elemIndex “01″)

Just to show that you can truly program brainfuck style in Haskell if you want to.

If you want to actually deal with the error, rather than crash, you are better off using something like the Maybe datatype:

readBin :: String -> Maybe Integer
readBin = foldl (\ x y -> do { c <- x; d <- elemIndex y “01″; return (d + (2*c)) }) (return 0)

I’ll leave the point-free version of this one as an excersize. You could either use Maybe utitily functions, or the monadic functions to achieve this.