list is immutable?

[mw66]

e.g.

$ ./chickenclisp 
=> (set x '(1 2 3))
[1, 2, 3]
=> (array-set-n x 0 4)
[4, 2, 3]
=> x
[1, 2, 3]

x is unchanged.

while in Lisp (SBCL), list is mutable:

* (defvar x '(1 2 3))
X
* x
(1 2 3)
* (setf (car x) 4)
4
* x
(4 2 3)

x is mutable.

[mw66]

and none of set, set-p, set-c can modify (car x):

$ ./chickenclisp 
=> (set x '(1 2 3))
[1, 2, 3]
=> (set (car x) 4)
object.Exception@source/orelang/Value.d(143): Enforcement failed

$ ./chickenclisp 
=> (set x '(1 2 3))
[1, 2, 3]
=> (set-p (car x) 4)
Segmentation fault (core dumped)

$ ./chickenclisp 
=> (set x '(1 2 3))
[1, 2, 3]
=> (set-c (car x) 4)
object.Exception@source/orelang/Value.d(182): Enforcement failed

[mw66]

The reason is in:

ChickenClisp/source/orelang/operator/ArrayOperators.d

Line 61 in 815c874

return new Value(arr);

ChickenClisp/source/orelang/Value.d

Line 84 in 815c874

this.opAssign(value);

ChickenClisp/source/orelang/Value.d

Line 240 in 815c874

void opAssign(T)(T[] value) if (!is(T == Value) && !is(T == immutable(char))) {

So int / number ... all other types array (except string i.e immutable(char)) ... is always copied on modification, I don't think it's Lisp list / array semantics.

This is a bug, actually the opposite is true: only immutable string (in D's semantics) should be always copied on modification.

[mw66]

Also what's the good of this init()?

ChickenClisp/source/orelang/Value.d

Line 368 in 815c874

void init() {

1. first, in opAssign(), init() is called, then this.type is set; all the ifs in init() is meaningless.
2. even if you want to check those so many ifs, why not using switch(this.type)? at least it will jump and break, to save some CPU cycle.