I’m not sure why it’s useful to explicitly type the primitives : why not use the stack directly ? (btw, adding state to lists is a nice exercise, but I wouldn’t use it in general : lists are very handy for recursion, stacks aren’t ^_^)

So, something like this might be simpler :

let dup (a::stack) = a::a::stack
let add (a::b::stack) = (a + b)::stack

let words = [ "dup", dup; "add", add ]

type input = Num of int | Word of string

let eval stack = function
| Num a -> a::stack
| Word w -> List.assoc w words stack

let process = List.fold_left eval []

Typechecking the expression seems to be more funny :) .

import java.io.*;
import java.util.ArrayList;

class Stack {
private ArrayList stack = new ArrayList ();
public void push(Integer i) { stack.add(i); }
public Integer pop() { return stack.remove(stack.size() – 1); }
public void swap() { push(stack.remove(stack.size() – 2)); }
public Integer peek() { return stack.get(stack.size() – 1); }
public String toString() { return stack.toString(); }
public void execute(String cmd) {
if (cmd.equals(“swap”)) { swap(); }
else if (cmd.equals(“dup”)) { push(peek()); }
else if (cmd.equals(“drop”)) { pop(); }
else if (cmd.equals(“+”)) { push(pop() + pop()); }
else if (cmd.equals(“-”)) { push(pop() – pop()); }
else if (cmd.equals(“*”)) { push(pop() * pop()); }
else if (cmd.equals(“/”)) { push(pop() / pop()); }
else { push(Integer.parseInt(cmd)); }
System.out.println(stack);
}
public static void main(String[] args) {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String line = “”;
Stack stack = new Stack();
while ((line = in.readLine()) != null) {
stack.execute(line);
}
} catch (Exception e) {
System.out.println(e);
}
}
}

5 – 1

;).

Seriously, nice work.

When ;; appears before let, type, open [and a few others] you can drop it.