immutability with var and def

[MarcusE1W]

I have a probably dumb question about immutability in Janet.

I understand I define immutable data with def and mutable data with var.
I also can use immutable tuples with e.g [1 2 3] and mutable arrays like @[1 2 3].

So what is this?

(def a @[1 2 3])
(var b [1 2 3]

What is that really and are a and b mutable or immutable ? Why would I use what?

And another question, whats the difference?

(def x 1)
(def x 2)
(var y 1)
(set y 2)

If I can def a new value at any time into x, how is x immutable? And what's the difference to y ?

[CosmicToast]

You're thinking of two different meanings of mutable and immutable.
There is (im)mutable data and (im)mutable bindings.
The conceptual @ sigil designates mutable data, while var and set are for mutable bindings.

Let's start by explaining (im)mutable bindings.
When you create a closure (all functions in janet are closures), you capture the current bindings.
So, for example:

(def a 5)
(defn pa [] (print a))
(pa) # => prints 5

This works because the pa function captured the a binding.
That binding is immutable, you cannot edit it.
Consider the following:

(def a 5)
(defn pa [] (print a))
(def a 6)
(pa) # => still prints 5

var declares a mutable binding.
It's a binding that can be modified without rebinding/shadowing it - closures do not capture new bindings (rebindings) that happened after their definitions.
So now we can do...

(var a 5)
(defn pa [] (print a))
(set a 6)
(pa) # => prints 6

This is because we modified the binding.
Note that the numbers themselves (5, 6) are still immutable data.
You can't really modify the concept of a number, eh? (ok, that's not how that works, but it's useful to think of it in those terms for our purposes).

So what's that about the data then?
Well, mutable data can be mutated, without ever doing a rebinding.
Consider this:

(def a {:key :value})
(defn pa [] (print (a :key)))
(pa) # => prints value

Let's say we wanted it to print newvalue.
We could make it a var and then set it after applying a transformation (and this is how many immutable-only languages work!).
However, we could also use mutable data and modify it "in-place", even though the binding is immutable:

(def a @{:key :value})
(defn pa [] (print (a :key)))
(put a :key :newvalue)
(pa) # => prints newvalue

Hopefully that clears it up.

[CosmicToast]

P.S. this isn't Janet-specific, this is how this works (with obviously the names being different) in most languages that have closures, dynamic bindings, and immutable data.

[MarcusE1W]

Thanks for the comprehensive answer.
The first part about the bindings is really clear.

Regarding the immutable data, is it fair to say that with

(def a @[1 2 3])
(var b @[1 2 3])

a and b are pretty much the same? Is there any difference ?

[CosmicToast]

It is different.
In the case of a, you have an immutable binding with mutable data.
In the case of b, you have a mutable binding with mutable data.
The mutability of the binding vs the data really have nothing to do with one another.
Here is another example:

(def a @[1 2 3])
(defn addx [x] (array/push a x))
(defn prnx [] (pp a))
(addx 4) # a is @[1 2 3 4]
(prnx) # => @[1 2 3 4]
(def a @[1]) # a is @[1], but the old capture is still valid
(addx 5) # the new a is a different binding, it was not modified
(prnx) # => @[1 2 3 4 5] since the old binding is still captured

On the converse, the same with mutable bindings:

(var a @[1 2 3])
(defn addx [x] (array/push a x))
(defn prnx [] (pp a))
(addx 4) # a is @[1 2 3 4]
(prnx) # => @[1 2 3 4]
(set a @[1]) # a is now @[1], the binding did not change
(addx 5) # a is now @[1 5]
(prnx) # => @[1 5]

If this answers all of your questions, don't forget to press the button that marks the topic as answered (for visibility reasons, answered topics are marked differently in the topic list).

[MarcusE1W]

This is great, I get it now,
I mark the last answer as solution, but of course the previous explanation is also important :-)