After messing with various functional languages for quite some time it still pleases me to see how clear and concise languages like Scala and Haskell are for this type of problem compared with C++ or Java.

I’ll re-paste the key part of the code, the evaluator.

private type Operation = ~[String, Double]
private type Expression = ~[Double, List[Operation]]

private def eval(value: Expression): Double = value match {
case lhs~ops => (
(lhs /: ops) ((acc, op) => op match {
case “+”~rhs => acc + rhs
case “-”~rhs => acc – rhs
case “*”~rhs => acc * rhs
case “/”~rhs => acc / rhs
})
)
}

The private types aren’t strictly necessary, but using them seemed more legible than declaring eval like this:

private def eval(value: ~[Double,List[~[String,Double]]]): Double

After seeing your code, I still wanted make a calculator that evaluates the input directly, rather than building up an AST first. Here’s my code to do that.

import scala.util.parsing.combinator._

class Arith extends JavaTokenParsers {
def expr: Parser[Double] =
term~rep(“+”~term | “-”~term) ^^ (eval(_))

def term: Parser[Double] =
factor~rep(“*”~factor | “/”~factor) ^^ (eval(_))

def factor: Parser[Double] = (
floatingPointNumber ^^ (_.toDouble)
| “(“~>expr (
// Use left fold to reduce the list
(lhs /: ops) ((acc, op) => op match {
case “+”~rhs => acc + rhs
case “-”~rhs => acc – rhs
case “*”~rhs => acc * rhs
case “/”~rhs => acc / rhs
})
)
}
}

object Calc extends Arith {
def main(args: Array[String]) {
if (args.isEmpty)
println(“usage: scala Calc EXPRESSION”)
else
println(parseAll(expr, args(0)))
}
}

Also noted my slight mix up with naming. Cabal is the build and packaging system and hackage is the actually repository. Oops. It is certainly good to see all the changes that have happened over the past couple of years.

Secondly, you didn’t mention one of the newest developments, the Industrial Haskell Group, http://industry.haskell.org/ , which supports the development of the language and tools for commercial users by funding direct development on the ecosystem. In the past year this has helped a lot with cabal, ghc and dynamic libraries, for example.

That is a good one, I had to fire up the scala interpreter to spot the mistake even with the hint.

Reminds me of the classic C/C++ mistake I have seen in real code, it goes something like this.

int x= SomeNumber();
int Value1 = 10;
int Value2 = 11;
switch(x)
{
case Value1:
doSomething();
break;
Value2:
doSomethingElse();
break;
default:
break;
}

Quite obviously in a small bit of code but hard to spot in production code.

val array = Array[Array[Int]](100, 100)

The error is “type mismatch; found: Int(100); required: Array[Int]“.

(Hint: I’ve already got something old, something borrowed, and something blue…)