The goal is to test how a programming language allows data sharing.

In Various Languages

I = Immutable, D = Deep, S = Shallow, C = Constructor is Constant (see below)

Language	integer	string	list/array	struct/object
C++	I	D	D	D
PHP	I	D	D	D
Perl	I	D(1)	D	S
Tcl	I	D?	D?	?

Python	I	I	S	S
Java	I	I	S	S
Javascript	I	I	S	S
C#	I	I	S	D/S

C	I	S,C	S	D
Smalltalk	I	S,C	S	S
Common Lisp	I	S,C	S	S

OCaml	I	S	I/S	S
Scheme	I	S	S	S
Ruby	I	S	S	S

(1) In Perl, "=" deep copies strings, whereas function calls use shallow copy.

Explainations

Deep vs Shallow Copy

The simplest explanation is an example in C:

Point *p2;
 p2 =  p; // shallow copy
*p2 = *p; // deep copy

char *s2;
s2 = s;        // shallow copy
strcpy(s2, s); // deep copy

When you deep copy a value, it breaks any sharing it has.
When you shallow copy a value, it keeps any sharing it has.

Languages using deep copy by default always have a special way to get a shallow copy:

in C: using the address-of operator "&"
in Perl: take the reference with "\" [1]
in C++, Perl and PHP: a function can specify that a parameter should be passed by reference

Languages using shallow copy by default sometimes have a way to get deep copy: copy in Smalltalk, Clone in C#, copy.copy in Python... (more, search "object cloning")

Immutable Value

An example of immutable value is 1. The programming language doesn't give you any functions that would allow you to modify its value.

Deep or shallow copying have the same result for immutable values.

Mutating variables containing an immutable value

Most languages introduce a (more or less magical) construct to modify the value contained by a variable.

In C++, overloading plus pass-by-reference handles this. Even "=" can be redefined.
In Java, Python or Ruby: "=" is the operator to change the value of a variable. "+=" and "++" [2] are not methods applied on the object, but mere macros relying on "=".

The usage of

immutable values together with special operators alike "+="
and implictly deep copied mutable values

is somewhat blurred.

Strings

Strings can be mutable or immutable. The current trend is immutable strings (Java, C#, Python) or deep copied mutable strings (Perl, PHP, C++)

Read-only strings

A mutable string can be constant. This is used for constant strings encountered in a program:

In C, Smalltalk and Common Lisp, "hello" is a constant value. If you try to modify it, you get a runtime error.

Ruby and OCaml don't have readonly strings, all strings are mutable:

Ruby behaves as if a new "hello" string is created each time it is encountered. In practice Ruby uses Copy On Write to duplicate the strings only when needed.

strings found in OCaml programs are mutable and shared:

       # let f () = "hello" in  (f()).[0] <- 'H'  ;  f();;
       - : string = "Hello"

Language	Code	Runtime Result
C	`"hello"[0] = 'H';`	segmentation fault
Smalltalk	`'hello' at: 1 put: $H`	object is read-only
Common Lisp	`(setf (aref "hello" 0) #\H)`	Attempt to modify a read-only string
Scheme	`(string-set! "hello" 0 #\H)`
OCaml	`"hello".[0] <- 'H'`
Ruby	`"hello"[0] = "H"`
Perl	`"hello" =~ s/h/H/`	Can't modify constant item

Mutable Numbers?!

A language that would seek complete orthogonality could treat numbers the same as other objects, i.e. have mutable numbers (Haskell notwithstanding of course).

With shallow copy, one gets:
i = 1 j = i j = j + 1
behaving alike this C++ code
int *i = new int(1); int *j = i; *j = *j + 1;
And both i and j are now 2 !
This is really counter-intuitive ; no programming language have this behaviour.
With deep copy, the behaviour of mutable numbers is alike immutable numbers, with the advantage (?) of having "+=" and "++" being really methods.

The main reason for having immutable numbers was performance and memory consumption. Maybe this will change?

Notes

[1] The address-of operator of Perl and C are different from the "ref" reference constructor of SML and OCaml. In Perl and C, it allows sharing the existing value, whereas ML's "ref" introduces sharing.

int i = 1; int *p = &i; *p = *p + 1;
i is modified
let i = 1 in let p = ref i in p := !p + 1
i is not modified

[2] To be precise "++" is not defined in Ruby. Some explanation about this.

Credits

Marcin 'Qrczak' Kowalczyk (fix the explanation about strings behaviour in OCaml and Ruby)

Pixel

This document is licensed under GFDL (GNU Free Documentation License).

Release: $Id$