Language features
Oz contains most of the concepts of the majorLanguage overview
Data structures
Oz is based on a core language with very few datatypes that can be extended into more practical ones through circle(x:0 y:1 radius:3 color:blue style:dots)
. Here the terms x,y, radius etc. are called features and the data associated with the features (in this case 0,1,3 etc.) are the values.
* Tuples: Records with integer features in ascending order: circle(1:0 2:1 3:3 4:blue 5:dots)
.
* Lists: a simple linear structure
Functions
Functions are first class values, allowing higher order functional programming:Higher-order programming
Functions are like other Oz objects. A function can be passed as an attribute to other functions or can be returned in a function.Anonymous functions
Like many other functional languages, Oz supports use of anonymous functions (i.e. functions which do not have a name) with higher order programming. The symbol $ is used to denote these. In the following, the square function is defined anonymously and passed, causing 4 9/code> to be browsed.
Since anonymous functions don't have names, it is not possible to define recursive anonymous functions.
Procedures
Functions in Oz are supposed to return a value at the last statement encountered in the body of the function during its execution. In the example below, the function Ret returns 5 if X > 0 and -5 otherwise.
declare
fun
if X > 0 then 5 else ~5 end
end
But Oz also provides a facility in case a function must not return values. Such functions are called procedures. Procedures are defined using the construct "proc" as follows
declare
proc
if X > 0 then else end
end
The above example doesn't return any value, it just prints 5 or -5 in the Oz browser depending on the sign of X.
Dataflow variables and declarative concurrency
When the program encounters an unbound variable it waits for a value. For example, below, the thread will wait until both X and Y are bound to a value before showing the value of Z.
thread
Z = X+Y
end
thread X = 40 end
thread Y = 2 end
The value of a dataflow variable cannot be changed once it is bound:
X = 1
X = 2 % error
Dataflow variables make it easy to create concurrent stream agents:
fun
if N Max then nil
else
N,
end
end
fun
case Stream
of nil then S
[] H, T then S,
end
end
local X Y in
thread X = end
thread Y = end
end
Because of the way dataflow variables work, it is possible to put threads anywhere in a program and guaranteed that it will have the same result. This makes concurrent programming very easy. Threads are very cheap: it is possible to have 100,000 threads running at once.
Example: Trial division sieve
This example computes a stream of prime numbers using the trial division
Trial division is the most laborious but easiest to understand of the integer factorization algorithms. The essential idea behind trial division tests to see if an integer ''n'', the integer to be factored, can be divided by each number in turn ...
algorithm by recursively creating concurrent stream agents that filter out non-prime numbers:
fun
case Xs of nil then nil
[] X, Xr then Ys in
thread Ys = end
X,
end
end
Laziness
Oz uses eager evaluation
In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a ''parameter-passing strategy'' that defines the kind of value that is passed to the f ...
by default, but lazy evaluation
In programming language theory, lazy evaluation, or call-by-need, is an evaluation strategy which delays the evaluation of an expression until its value is needed (non-strict evaluation) and which also avoids repeated evaluations (sharing).
The b ...
is possible. Below, the fact is only computed when value of X is needed to compute the value of Y.
fun lazy
if N =< 0 then 1 else N* end
end
local X Y in
X =
Y = X + 1
end
Lazy evaluation
In programming language theory, lazy evaluation, or call-by-need, is an evaluation strategy which delays the evaluation of an expression until its value is needed (non-strict evaluation) and which also avoids repeated evaluations (sharing).
The b ...
gives the possibility of storing truly infinite data structures in Oz. The power of lazy evaluation can be seen from the following code sample:
declare
fun lazy
case Xs#Ys
of (X, Xr)#(Y, Yr) then
if X < Y then X,
elseif X>Y then Y,
else X,
end
end
end
fun lazy
case Xs
of nil then nil
[] X, Xr then N*X,
end
end
declare H
H = 1 ,
The code above elegantly computes all the Regular Numbers
in an infinite list. The actual numbers are computed only when they are needed.
Message passing concurrency
The declarative concurrent model can be extended with message passing
In computer science, message passing is a technique for invoking behavior (i.e., running a program) on a computer. The invoking program sends a message to a process (which may be an actor or object) and relies on that process and its supporting i ...
via simple semantics:
declare
local Stream Port in
Port =
% Stream is now 1, _ ('_' indicates an unbound and unnamed variable)
% Stream is now 1, 2, _
...
% Stream is now 1, 2, .. , n, _
end
With a port and a thread, asynchronous agents can be defined:
fun
Msg Out in
thread end
end
State and objects
It is again possible to extend the declarative model to support state and object-oriented programming with very simple semantics. To create a new mutable data structure called Cells:
local A X in
A =
A := 1 % changes the value of A to 1
X = @A % @ is used to access the value of A
end
With these simple semantic changes, the whole object-oriented paradigm can be supported. With a little syntactic sugar, OOP becomes well integrated in Oz.
class Counter
attr val
meth init(Value)
val:=Value
end
meth browse
end
meth inc(Value)
val :=@val+Value
end
end
local C in
C =
end
Execution speed
The execution speed of a program produced by the Mozart compiler (version 1.4.0 implementing Oz 3) is very slow. On a 2012 set of benchmarks it averaged about 50 times slower than that of the GNU Compiler Collection
The GNU Compiler Collection (GCC) is an optimizing compiler produced by the GNU Project supporting various programming languages, hardware architectures and operating systems. The Free Software Foundation (FSF) distributes GCC as free software ...
(GCC) for the C language.The Computer Language Benchmarks Game
/ref>
See also
* Alice (programming language)
Alice ML is a programming language designed by the Programming Systems Laboratory at Saarland University, Saarbrücken, Germany. It is a dialect of Standard ML, augmented with support for lazy evaluation, concurrency ( multithreading and dist ...
, a concurrent functional constraint language from Saarland University
* Dataflow programming
In computer programming, dataflow programming is a programming paradigm that models a program as a directed graph of the data flowing between operations, thus implementing dataflow principles and architecture. Dataflow programming languages share s ...
* Functional logic programming languages
Functional may refer to:
* Movements in architecture:
** Functionalism (architecture)
** Form follows function
* Functional group, combination of atoms within molecules
* Medical conditions without currently visible organic basis:
** Functional sy ...
** Curry (programming language)
Curry is an experimental functional logic programming language, based on the Haskell language. It merges elements of functional and logic programming, including constraint programming integration.
It is nearly a superset of Haskell, lacking ...
** Mercury (programming language)
Mercury is a functional logic programming language made for real-world uses. The first version was developed at the University of Melbourne, Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's su ...
** Visual Prolog
Visual Prolog, previously known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog. As Turbo Prolog, it was marketed by Borland but it is now developed and marketed by the Danish firm PDC that originally crea ...
, an object-oriented, functional, logic language
References
* Peter Van Roy and Seif Haridi (2004). '' Concepts, Techniques, and Models of Computer Programming''. MIT Press. There i
online supporting material
for this book. The book, an introduction to the principles of programming languages, uses Oz as its preferred idiom for examples.
External links
*
One of the core developers of Mozart/Oz, this group does research using Mozart/Oz as the vehicle
Conference which gives a snapshot of the work being done with Mozart/Oz
Programming in Oz
{{DEFAULTSORT:Oz (programming language)
Multi-paradigm programming languages
Functional logic programming languages
Logic programming languages
Dynamically typed programming languages
Prototype-based programming languages
Concurrent programming languages
Educational programming languages
Programming languages created in 1991