Tower of Hanoi, as far as I understand its performance, is IO bound. In Smalltalk, I guess I could output to the Transcript which is terribly slow (their own words!). My interest in Smalltalk is purely non-performance related … although it has been claimed faster than Ruby in most cases. We’ll see how that goes.

wrt Haskell.

Thanks! I googled for “haskell performance” last night after I posted this. There are a number of tips and tricks out there. I had not been looking to make this really fast. In fact, I could have adopted a more imperative style to make it faster and forego the list creation completely … but that wouldn’t be very Haskell-ish.

This slight refactor:

import System.Environment

showMove src dst = putStrLn (show src ++ ” -> ” ++ show dst)

data T = One | Two | Three
deriving Show

hanoi :: Int -> T -> T -> T -> [(T, T)]
hanoi 1 src dst acc = [(src, dst)]
hanoi n src dst acc = hanoi (n-1) src acc dst ++
hanoi 1 src dst acc ++
hanoi (n-1) acc dst src

main = do
args <- getArgs
let n = read (head args)
mapM_ (uncurry showMove) (hanoi (n :: Int) One Two Three)

Runs in 10seconds on my box, when compiled:

ghc -O2 A.hs

Note its extrememly naive — you could for a start replace (++) on lists by an O(1) append operation.

I’m surprised about Haskell. Looking at http://shootout.alioth.debian.org/ it seems to perform quite well.

Also Lua and Io look very interesting too.

Nice post!

I make no claim at expertise in Haskell, and here’s what I had come up with: http://s3.amazonaws.com/mps/hanoi.hs

You can compare that with http://www.kernelthread.com/hanoi/html/hs.html which generates the whole list in memory (lazily, of course) and outputs it. Keep in mind that 20 rings represents 2^20 lines of output.

Haskell is a fun language with a lot of will-hurt-your-brain ideas … I don’t want to make it sound like this is representative of anything.