Hacky Attempt At Haskell Reverse Polish Notation

gistfile1.hs

solveRPN :: String -> Double
solveRPN [] = 0
solveRPN s = head $ foldl solveRPN' [] $ words s

solveRPN' :: [Double] -> String -> [Double]
solveRPN' (x2:x1:stack) "+" = (x1 + x2):stack
solveRPN' (x2:x1:stack) "-" = (x1 - x2):stack
solveRPN' (x2:x1:stack) "*" = (x1 * x2):stack
solveRPN' stack num = (read num):stack

Why are you using the tail end of the list as top of the stack instead of the head end?

Good question. I was keeping it in the same order as it is written. I peeked at the answer and its a lot easier doing it the other way. I plan to attempt it again the correct way.

It's easier and -- above all -- it's more efficient to use the head end.

Later today I could post a solution using the state monad.

I see that you've rewritten the code. Now it's much more legible.

Here's a solution using the State monad:

import Control.Monad.State

solveRPN :: String -> Double
solveRPN s = head $ execState (sequence $ map handle $ words s) []

handle :: String -> State [Double] ()
handle "+" = handleBinOp (+)
handle "-" = handleBinOp (-)
handle "*" = handleBinOp (*)
handle s = push (read s)

handleBinOp :: (Double -> Double -> Double) -> State [Double] ()
handleBinOp op = do
    x1 <- pop
    x2 <- pop
    push (op x2 x1)


push :: Double -> State [Double] ()
push x = do
    stack <- get
    put (x : stack)

pop :: State [Double] Double
pop = do
    (x : stack) <- get
    put stack
    return x

Great, thanks!