Pico: Scheme for mere mortals

Pico: Scheme for mere 

mortals 

Wolfgang De Meuter 

Theo D’Hondt 

Programming Technology Lab 

Vrije Universiteit Brussel 

= 10 -12 

http://pico.vub.ac.be

A Linked List in C++ 

template class List 

{ 

public: 

! struct Node 

! { 

! ! Node(const T& data, Node* next=0):data(data),next(next) {} 

! ! Node* next; 

! ! T data; ! void swap(List& x) 

! }; 

! { 

! 

! ! Node* tmp = head; head = x.head; x.head = tmp; 

List() : head(0) ! {}} 

! List(const List& ! L) List& : head(0) operator=(const List& x) 

! { 

! { 

! ! for ( const ! Node* ! List i = L.begin(); tmp(x); i!= L.end(); i=i->next ) 

! ! ! push_front(i->data); 

! ! swap(tmp); 

! ! reverse(); ! ! return *this; 

! } 

! } 

C++ = 10 12 

! void reverse() ! ~List() { clear(); } 

! { 

! void clear() { while (!empty()) ! T& front() pop_front(); { return } head->data; } 

! ! Node* p = 0; Node* i = begin(); Node* n; 

! const T& front() const { return head->data; } 

! ! while (i)! bool empty() { return !head; } 

! ! { 

! Node* begin() { return head; } 

! ! ! n = i->next; 

! void push_front(const ! T& x) Node* { end() { return 0; } 

! ! ! i->next ! = ! p; Node* tmp = new Node(x,head); head = tmp; 

! ! ! p = i; ! i } = n; 

! const Node* begin() const { return head; } 

! ! } 

! const Node* end() const { return 0; } 

! ! head = p; ! void pop_front() { 

! } 

! ! if (head) { Node* private: tmp = head; head=head->next; delete tmp; } 

! } 

! Node* head; 

};

A Linked List in Scheme 

(define l (list 1 2 3 4 5)) 

(car l) 

(cdr l) 

(cons 0 l) 

(eq? l1 l2) 

(define head car) 

(define tail cdr) 

(define (reverse l) 

(define (reverse-iter l a) 

(if (null? l) 

a 

(reverse-iter (cdr l) (cons (car l) a)))) 

(reverse-iter l ()))

Good Reasons for Scheme 

• LISP Derivative 

• It’s small & full of fundamental concepts 

• It’s extremely powerful 

• Automatic GC & Dynamically Typed 

• Interactive Programming 

• Portable (R6RS) 

• Higher Order Programming Made Easy 

• Meta-Programming for Real : Extensible 

• Validated by Industrial Applications

Argument against Scheme 

(define (QuickSort V Low High) 

(define Left Low) 

(define Right High) 

(define Pivot (vector-ref V (quotient (+ Left Right) 2 ))) 

(define Save 0) 

(do ((stop #f (> Left Right))) (stop) 

(do () ((>= (vector-ref V Left) Pivot)) 

(set! Left (+ Left 1))) 

(do () ((

Pico: Scheme for mere mortals 

QuickSort(V, Low, High): 

{ Left: Low; 

Right: High; 

Pivot: V[(Left + Right) // 2]; 

Save: 0; 

until(Left > Right, 

{ while(V[Left] < Pivot, Left:= Left+1); 

while(V[Right] > Pivot, Right:= Right-1); 

if(Left Left, QuickSort(V, Left, High)) }

Another Teaser: Linked Lists 

{ pair(x,y):[x,y]; 

is_pair(x):if(is_table(x),size(x)=2,false); 

head(l):if(is_pair(l), 

l[1], 

error(“not a pair”)); 

tail(l):if(is_pair(l), 

l[2], 

error(“not a pair”)); 

list@tab:{ walk(t):if(t=size(tab)+1, 

void, 

pair(tab[t],walk(t+1))); 

walk(1)}; 

is_null(x):is_void(x); 

reverse(l):{ reverse_iter(l1,l2): 

if(is_null(l1), 

l2, 

reverse_iter(cdr(l1),pair(car(l1),l2))); 

reverse_iter(l,void)} 

}

The Dictionary* 

program 

dictionary = { (name, value) } 

eval 

value 

reference 

dictionary = { (name, value) } 

addition 

*aka The Evaluation Environment 

{ i:0; 

from1To10[10]:(i:=i+1); 

succ(x):x+1; 

i:=0; 

from2To11[10]:succ(from1To10[i:=i+1]); 

display(from1To10); 

display(eoln); 

display(from2To11) 

} 

overwriting

Fundamental Concepts 

dictionary 

operations 

reference addition overwriting 

invocations 

name 

pi 

variable 

reference 

pi:3.14 

variable 

definition 

pi:=3.1459 

variable 

assignment 

name[exp] 

A[i] 

table 

reference 

A[10]:5 

table 

definition 

A[i+3]:=7 

table 

assignment 

name(exp, ..., exp) 

id(5) 

function 

application 

id(x):x 

function 

definition 

id(x):=x+4 

function 

assignment

+ Syntactic Sugar: 

+ Bells and Whistles 

{ x:1; y:2; z:x+y } 

... sequencing ... 

begin(x:1,y:2,z:x+y) 

[ 1, “hi!”, 3.14 ] 

3+4 

x

Foundation: Functions 

{ t:4; 

f(x): { g(y): x+y+t; 

g } 

myG:f(4); 

myG(6) 

} 

f 

t 4 

“f” 

[“x”] 

{ g(y) ... } 

x 4 

myG 

g 

“g” 

[“y”] 

x+y+t 

y 6

Table Arguments 

main@args:{ 

display(args[1],args[2]) 

} 

main(1,2,3) 

accumulate@t: 

for(i:(res:0)+1,i

Functional Arguments (1) 

zero(a, b, f(x), epsilon): 

{ c: (a+b)/2; 

if(abs(f(c)) < epsilon, 

c, 

if(f(a)*f(c) < 0, 

zero(a, c, f(x), epsilon), 

zero(c, b, f(x), epsilon))) } 

zero(-2,2, x, 0.01) 

zero(-1,1, x*x-5, 0.001)


selection(t,l


The Essence 

{ delay(exp()):exp; 

force(exp):exp() 

} 

{ e:delay(display(x)); 

x:3; 

force(e) 

}


true(t, f()): t 

false(t(), f): f 

if(cond, t(), f()): cond(t(),f()) 

while(cond(), exp()): 

{ loop(value, pred): pred(loop(exp(), cond()), value); 

loop(void, cond()) } 

for(i,p(), c(), e()): 

while(c(),{v:e();p();v})


{ tag => fun: 

[tag, fun]; 

else: 0; 

} 

case@clauses: 

{ default: void; 

siz: size(clauses); 

max: 0; 

for(k: 1, k:= k+1, not(k > siz), 

{ clause: clauses[k]; 

if(clause[1] = else, 

default:= clause[2], 

if(clause[1] > max, 

max:= clause[1], 

void)) { raise(exc,val):error(“UNCAUGHT }); 

EXCEPTION”); 

tbl[max]: default; 

for(k: 1, k:= k+1, trycatch(try(), not(k > siz), filter(exception),catch(exception,value)): 

{ clause: clauses[k]; call({ keep:raise; 

if(clause[1] = else, raise(id,retval):={ 

void, 

raise:=keep; 

tbl[clause[1]]:= clause[2]) if(filter(id), }); 

continue(cont,catch(id,retval)), 

select(tag): 

raise(id,retval))}; 

if(tag > max, default, res:try(); 

tbl[tag]) } 

raise:=keep; 

res}) }

Implementation 

• 8000 lines of C 

• Mark&Sweep GC 

• Multi-threaded 

• Continuation Passing Style (100% Tail Recursive) 

• Windows, MacOS, Linux 

http://prog.vub.ac.be/~tjdhondt/ICP2/HTM.dir/introduction.htm

Pico as a Teaching Tool 

• pre-2002: 1st year of Sciences 

• Biology: Pico as a Fractal-Lab 

• Math: Pico as a Numerical Experimentarium 

• Physics: Pico as a Simulation Engine 

• Chemistry: Pico as a Mini DBMS + Query System 

• 1st year Mathematics (“Programming in 10Hrs”) 

• 2nd year Computer Science (“Interpretation of Computer 

Programs II”) 

http://prog.vub.ac.be/

Pico as a Research Tool 

• Borg: Agent-version of Pico 

• Pic%: Object-Oriented Extension of Pico 

• Sic%: Implementation in Smalltalk 

• JavaPico: Implementation in Java 

• ChitChat: Pic% with Distribution and Mobility 

• AmbientTalk: Pico for PDA’s 

http://prog.vub.ac.be/

Pico: Summary 

Fundamental Concepts 

dictionary 

operations 

invocations 

reference addition overwriting 

+ Bells and Whistles 

+ Syntactic Sugar: 

{ x:1; y:2; z:x+y } 

... sequencing ... 

begin(x:1,y:2,z:x+y) 

name 

name[exp] 

name(exp, ..., exp) 

pi 

variable 

reference 

A[i] 

table 

reference 

id(5) 

function 

application 

pi:3.14 

variable 

definitio 

A[10]:5 

table 

definitio 

id(x):x 

function 

definitio 

pi:=3.1459 

variable 

assignment 

A[i+3]:=7 

table 

assignment 

id(x):=x+4 

function 

assignment 

[ 1, “hi!”, 3.14 ] 

3+4 

x

Pico: Scheme for mere mortals

Create successful ePaper yourself

Delete template?

Save as template?