1
CMSC 330: Organization of
Programming Languages
Objects vs. Functional
Programming
CMSC 330 2
OOP vs. FP
Object-oriented programming (OOP)
•
Computation as interactions between objects
•
Objects encapsulate mutable data (state)
Accessed / modified via object’s public methods
Functional programming (FP)
•
Computation as evaluation of functions
Mutable data used to improve efficiency
•
Higher-order functions implemented as closures
Closure = function + environment
CMSC 330 3
An Integer “Stack” Abstraction in Java
class Stack {
class Node {
Integer val; Node next;
Node(Integer v, Node n) { val = v; next = n; }
};
private Node theStack;
void push(Integer v) {
theStack = new Node(v, theStack);
}
Integer pop() {
if (theStack == null)
throw new NoSuchElementException();
Integer temp = theStack.val;
theStack = theStack.next;
return temp;
}
}
CMSC 330 4
A “Stack” Abstraction in OCaml
module type STACK =
sig
type 'a stack
val new_stack : unit -> 'a stack
val push : 'a stack -> 'a -> unit
val pop : 'a stack -> 'a
end
module Stack : STACK =
struct
type 'a stack = 'a list ref
let new_stack () = ref []
let push s x = s := (x::!s)
let pop s = match !s with
[] -> failwith "Empty stack"
| (h::t) -> s := t; h
end
CMSC 330 5
Another “Stack” Abstraction in OCaml
let new_stack () =
let this = ref [] in
let push x = this := (x::!this)
and pop () = match !this with
[] -> failwith "Empty stack"
| (h::t) -> this := t; h
in
(push, pop)
# let s = new_stack ();;
val s : ('_a -> unit) * (unit -> '_a) = (<fun>, <fun>)
# Pervasives.fst s 3;; (* applies 1
st
part of s to 3 *)
- : unit = ()
# Pervasives.snd s ();; (* applies 2
nd
part of s to () *)
- : int = 3
CMSC 330 6
Two OCaml Stack Implementations
1
st
implementation (OOP style)
•
Based on modules
•
Specifies methods for
Creating stack
Pushing value onto stack parameter
Popping value from stack parameter
2
nd
implementation (FP style)
•
Based on closures
•
Creating stack returns tuple containing
Closure for pushing value onto created stack
Closure for popping value from created stack
