Comments on: Foray Into Haskell

By: akrish » Blog Archive » Dynamic Programming in Haskell and why DP is useful

Sun, 28 Jun 2009 19:01:22 +0000

[...] and as I like to learn by doing, I’ve been implementing common algorithms in the language. Last week I tackled depth first search and found it to be surprisingly challenging and consequently really [...]

By: akshayk

akshayk — Fri, 26 Jun 2009 18:12:15 +0000

@Jedai: yes you’re right. I mentioned that I just started learning Haskell and in as much as I’ve learned, I haven’t gotten to Array’s yet. I’m sure they are very cool and highly useful as a language construct.
Also thanks for the FGL link. I will check that out.

By: Jedaï

Jedaï — Thu, 25 Jun 2009 18:38:13 +0000

Why do you consider immutable arrays “cheating” ? They’re immutable, it’s not like they’re impure in any way. You can do lot of cool stuff with Haskell arrays : especially keeping in mind that they’re lazy by default so you can use them in their own initialization, it’s surprising how much can be done thanks to that.

I must say though that graphs and algorithms on them have always been something of a problem in pure functional languages, there are some interesting approach around (look at FGL http://hackage.haskell.org/cgi-bin/hackage-scripts/package/fgl for instance).

By: akshayk

akshayk — Thu, 25 Jun 2009 13:54:10 +0000

Thanks for the comments guys. Good to know people are interested…
@InternetGuy: As I mentioned, I’m still really knew to Haskell so thanks for the “deriving” tip. I should caught that unnecessary lambda though. Didn’t know about list comprehensions so thanks for that too!
@jberryman these are all techniques i’ve read about but didn’t know it is the norm in terms of programming practices. Thanks!

By: jberryman

jberryman — Wed, 24 Jun 2009 22:59:54 +0000

… sorry about the formatting. I tried to stick it in a tag

By: jberryman

jberryman — Wed, 24 Jun 2009 22:58:44 +0000

Hi! Without really looking at what your code is doing or testing the following, I thought I would post a version of your last code block that is a little more idiomatic and better (and sometimes just different) in some other ways as well:

dfsIterateOverNeighbors :: Graph -> [Integer] -> [Node]
dfsIterateOverNeighbors g [] = []
dfsIterateOverNeighbors g (v:vs) =
let firstNode = fromJust (getNode g v)
newG = removeNode g (getId firstNode)
neighbors = filter (isJust . getNode newG) (getAdjList firstNode)
newToVisit = neighbors ++ filter (not . flip contains neighbors) vs

in firstNode : dfsIterateOverNeighbors newG newToVisit

depthFirstSearch g =
dfsIterateOverNeighbors g . return . getId . fromJust . getNode g

Hope that type-checks!

By: Some Internet Guy

Some Internet Guy — Wed, 24 Jun 2009 21:10:35 +0000

You could also write makeNode more concisely with list comprehensions, which are supposed to look like set-builder notation:


makeNode ind eList = Node ind ([ y | (x,y) <- eList, x==ind] ++ [ x | (x,y) <- eList, y==ind])

By: Some Internet Guy

Some Internet Guy — Wed, 24 Jun 2009 21:07:37 +0000

You can automatically derive the Show class for your type.

data Node = Node Integer [Integer] deriving Show

You can also derive Eq (equality comparison) and Read (simple parsing), among others.

Also, ‘(\x -> fst)’ can be written more concisely as ‘fst’.