It's 2 (except , instead of ;)

I tried to find a balance between immutaibility and familiarity. Dagger (and, well, me) really wants immutability everywhere, but if we go too far with immutability in Dang I worry newcomers would struggle.

In short: local mutation is allowed, but object mutation is actually transparently made copy-on-write + local.

In the simple case (x = y) it updates x in the nearest lexical scope that defined it:

let a = 1
if (true) {
  a = 2
  print(a)
}
print(a)

# 2
# 2

In the case of assigning attributes (foo.bar = 2), it's actually copy-on-write.

foo.bar.baz = 2

This actually does something like this (pseudocode):

foo = clone(foo)
foo.bar = clone(foo.bar)
foo.bar.baz = 2

Where clone is a cheap¹ linked-list type operation (new empty scope with previous value as its parent).

I spent a lot of time trying to think of a clever syntax that made this more explicit, but nothing really beat just dumb reassignment on grounds of familiarity and footgun avoidance. It's hard to beat foo.bar += ["baz"].

Here's the test demonstrating all of it:

dang/tests/test_reassignment.dang

Lines 1 to 41 in 4f3779e

    
           # Test reassignment functionality 
        
           pub x = 42 
        
           pub y = "hello" 
        
           pub flag = true 
        
           # Test basic reassignment 
        
           x = 100 
        
           assert { x == 100 } 
        
           # Test string reassignment 
        
           y = "world" 
        
           assert { y == "world" } 
        
           # Test boolean reassignment 
        
           flag = false 
        
           assert { flag == false } 
        
           # Test reassignment in blocks 
        
           { 
        
             assert("slot inherited type and was assigned locally") { x == 100 } 
        
             x = 200 
        
             assert("slot inherited type and was assigned locally") { x == 200 } 
        
           } 
        
           assert("updates the outer slot, because the block did not declare its own") { x == 200 } 
        
           let fs = {{a: {{b: {{c: 42}}}}}} 
        
           fs.a.b.c = 100 
        
           assert { fs.a.b.c == 100 } 
        
           fs.a.b.c += 50 
        
           assert { fs.a.b.c == 150 } 
        
           # Test copy-on-write semantics 
        
           let original = {{a: {{b: {{c: 1}}}}}} 
        
           let modified = original 
        
           modified.a.b.c = 2 
        
           assert { original.a.b.c == 1 } 
        
           assert { modified.a.b.c == 2 } 
        
           print("Reassignment tests passed!")

Note: immutability also applies to re-assigning on self! (details)

(Leaving this open until there are docs)

For Dang's pretty low bar, anyway. ↩

	# Test reassignment functionality

	pub x = 42
	pub y = "hello"
	pub flag = true

	# Test basic reassignment
	x = 100
	assert { x == 100 }

	# Test string reassignment
	y = "world"
	assert { y == "world" }

	# Test boolean reassignment
	flag = false
	assert { flag == false }

	# Test reassignment in blocks
	{
	assert("slot inherited type and was assigned locally") { x == 100 }
	x = 200
	assert("slot inherited type and was assigned locally") { x == 200 }
	}
	assert("updates the outer slot, because the block did not declare its own") { x == 200 }

	let fs = {{a: {{b: {{c: 42}}}}}}
	fs.a.b.c = 100
	assert { fs.a.b.c == 100 }

	fs.a.b.c += 50
	assert { fs.a.b.c == 150 }

	# Test copy-on-write semantics
	let original = {{a: {{b: {{c: 1}}}}}}
	let modified = original
	modified.a.b.c = 2
	assert { original.a.b.c == 1 }
	assert { modified.a.b.c == 2 }

	print("Reassignment tests passed!")

Footnotes

Are variables mutable? #4

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions