> Mutability

> By default, variables are mutable. You can enable Immutable by Default mode using a directive.

> //> immutable-by-default

> var x = 10; > // x = 20; // Error: x is immutable

> var mut y = 10; > y = 20; // OK

Wait, but this means that if I’m reading somebody’s code, I won’t know if variables are mutable or not unless I read the whole file looking for such directive. Imagine if someone even defined custom directives, that doesn’t make it readable.

▲ andai 13 hours ago | parent | next [-]

Given an option that is configurable, why would the default setting be the one that increases probability of errors?

For some niches the answer is "because the convenience is worth it" (e.g. game jams). But I personally think the error prone option should be opt in for such cases.

Or to be blunt: correctness should not be opt-in. It should be opt-out.

I have considered such a flag for my future language, which I named #explode-randomly-at-runtime ;)

	▲	miroljub 11 hours ago \| parent \| next [-]
		> Or to be blunt: correctness should not be opt-in. It should be opt-out. One can perfectly fine write correct programs using mutable variables. It's not a security feature, it's a design decision. That being said, I agree with you that the author should decide if Zen-C should be either mutable or immutable by default, with special syntax for the other case. As it is now, it's confusing when reading code.
	▲	psychoslave 9 hours ago \| parent \| prev \| next [-]
		But why put it as a global metaswitcher instead of having different type infered from initial assignation qualifier? Example: `let integer answer be 42 — this is a constant set integer temperature be 37.2 — this is a mutable` Or with the more esoglyphomaniac fashion `cst ↦ 123 // a constant is just a trivial map st ← 29.5 // initial assignment inferring float`
	▲	Y_Y 11 hours ago \| parent \| prev \| next [-]
		> I have considered such a flag for my future language, which I named #explode-randomly-at-runtime ;) A classic strategy! https://p-nand-q.com/programming/languages/java2k/
	▲	Dylan16807 7 hours ago \| parent \| prev [-]
		> Given an option that is configurable, why would the default setting be the one that increases probability of errors? They're objecting to the "given", though. They didn't comment either way on what the default should be. Why should it be configurable? Who benefits from that? If it's to make it so people don't have to type "var mut" then replace that with something shorter! (Also neither one is more 'correct')

▲ maxbond 6 hours ago | parent | prev | next [-]

It's not ideal but it seems like something an LSP could tell you on a hover event. I didn't see an LSP (I didn't look that hard either) but presumably that's within the scope of their mission statement to deliver modern language ergonomics. (But I agree with sibling comments that this should be a keyword. Another decent alternative would be that it's only global in scope.)

▲ gmueckl 10 hours ago | parent | prev | next [-]

Other languages also have non-local qays of influencing compiler behavior, for example attributes in rust (standard) or compiler pragmas in C (non-standard).

When reading working code, it doesn't matter whether the language mode allows variable reassignment. It only matters when you want to change it. And even then, the compiler will yell at you when you do the wrong thing. Testing it out is probably much faster than searching the codebase for a directive. It doesn't seem like a big deal to me.

▲ netbioserror 12 hours ago | parent | prev [-]

Yeah, immutability should probably use a `let` keyword and compiler analysis should enforce value semantics on those declarations.

▲ phcreery 8 hours ago | parent [-]

Agreed, using `var` keyword for something that is non-var-ying (aka immutable) is not very intuitive.

▲ ekipan 3 hours ago | parent [-]

Mutability is distinct from variability. In Javascript only because it's a pretty widely known syntax:

    const f = (x) => {
      const y = x + 1;
      return y + 1;
    }

y is an immutable variable. In f(3), y is 4, and in f(7), y is 8.

I've only glanced at this Zen-C thing but I presume it's the same story.

	▲	Deanoumean 2 hours ago \| parent [-]
		"immutable variable" is an oxymoron. Just because Javascript did it does not mean every new language has to do it the same way.