Mirror of forum.nim-lang.org

12737 :: Understanding internal mutability of nested objects

• khaledh-nim (orginal) [2025-03-22T16:19:21+01:00] view original

  I'm a bit puzzled by how internal mutability works in Nim. Let's take this first example:

  
  type
    Foo = object
      id: int
  
  proc mutateFoo(f: var Foo) =
    f.id = 5
  
  let f = Foo()
  mutateFoo(f)
  Run

  This understandably fails to compile because f is immutable:

  
  Error: type mismatch
  Expression: mutateFoo(f)
    [1] f: Foo
  
  Expected one of (first mismatch at [position]):
  [1] proc mutateFoo(f: var Foo)
    expression 'f' is immutable, not 'var'
  Run

  Now, let's add another type:

  
  type
    Bar = object
      f: Foo
  
  proc mutateBar(b: var Bar) =
    mutateFoo(b.f)
  
  let b = Bar()
  mutateBar(b)
  Run

  This, also understandably, doesn't compile for the same reason: b is immutable. Now let's change mutateBar to take Bar instead of var Bar:

  
  Error: type mismatch
  Expression: mutateFoo(b.f)
    [1] b.f: Foo
  
  Expected one of (first mismatch at [position]):
  [1] proc mutateFoo(f: var Foo)
    expression 'b.f' is immutable, not 'var'
  Run

  This is also expected, since b.f is immutable as well. But if I change the declaration of Bar to be ref object instead, suddenly it compiles. So I try to test if I change mutateBar to take var Bar again (now that Bar is a ref type), it still complains that b is immutable.

  My question is: Why is it ok to mutate a ref object nested field indirectly (through a var parameter), but not the object itself?

---

• Araq (orginal) [2025-03-22T16:47:05+01:00] view original

  In short, it's because otherwise the language design falls apart and doesn't work anymore.

---

• khaledh-nim (orginal) [2025-03-22T17:41:49+01:00] view original

  TIL about strictFuns. Thanks.

  To be clear, I understand why passing an immutable object to a var param is forbidden, as we shouldn't be allowed to modify the passed variable. I just wasn't sure why passing an immutable parent ref object allows mutation of its fields. It sounds like strictFuncs prevents that behaviour.

---

• crfout (orginal) [2025-03-22T18:06:08+01:00] view original

  You're confusing the reference with the referred.

  This compiles and runs correctly, using a var object and a var parameter:

  
  # Don't know why it's stripping out the indentation.
  type
  Foo = object
  id: int
  
  Bar = object
  f: Foo
  
  proc mutateFoo(f: var Foo) =
  f.id = 5
  
  proc mutateBar(b: var Bar) =
  mutateFoo(b.f)
  
  var b = Bar()
  mutateBar(b)
  assert b.f.id == 5
  Run

  This also compiles and runs correctly, using a let ref object and an immutable parameter:

  
  type
  Foo = object
  id: int
  
  Bar = ref object
  f: Foo
  
  proc mutateFoo(f: var Foo) =
  f.id = 5
  
  proc mutateBar(b: Bar) =
  mutateFoo(b.f)
  
  let b = Bar()
  mutateBar(b)
  assert b.f.id == 5
  Run

  You're not changing the reference, you're changing the data inside the object being referred to.

  I hope that clears things up for you.

---

• khaledh-nim (orginal) [2025-03-22T18:49:54+01:00] view original

  You're not changing the reference, you're changing the data inside the object being referred to.

  I understand that. The confusing part was why the immutability of the ref object did not propagate to its fields.

  Consider this:

  
  type
    Foo = object
      id: int
    Bar = ref object
      f: Foo
  
  let s = @[Foo(id: 5)]
  s[0].id = 10  # Error: 's[0].id' cannot be assigned to
  
  let b = Bar(f: s[0])
  b.f.id = 10    # OK! even though b is immutable
  
  proc getF(b: Bar): Foo = b.f
  getF(b).id = 10 # Error: 'getF(b).id' cannot be assigned to
  Run

  IIUC, seq is a ref type, so why is s[0].id = 10 rejected but b.f.id = 10 is not? My guess is that [] returns an immutable view into the seq element (since it's defined let), in the same vein that getF() returns an immutable type. It's the part in which reaching directly for a ref type field is considered mutable that was a bit puzzling to me.

  All good now. Thanks.

---

• ElegantBeef (orginal) [2025-03-22T19:34:54+01:00] view original

  seq in Nim is treated as a value type. The reason of the immutable error is that [] operator takes in a var seq[T] and returns a var T. One could if they really hated themselves introduce a [] operator that took in a seq[T] and returned a var T.

---

• khaledh-nim (orginal) [2025-03-22T21:05:40+01:00] view original

  One could if they really hated themselves introduce a [] operator that took in a seq[T] and returned a var T.

  Well, that's how the dot operator works with ref types, hence my surprise: it takes an immutable ref and returns a mutable field of the object.

  I think the best way to remember this is to compare it to C const pointers vs. pointers to const:

  • immutable ref -> T* const myVar (const pointer to mutable location)
  • mutable ref -> T* myVar (mutable pointer to mutable location)

  IIUC, strictFunc changes the immutable ref semantics to:

  • immutable ref -> const T* const myVar (const pointer to const location)

  which is what I was looking for.

---

• crfout (orginal) [2025-03-23T18:59:25+01:00] view original

  @kaledh-nim has brought up a couple of important yet subtle issues here, and I think they are worth a more basic explanation for those reading this later.

  This doesn't compile because getf() returns an immutable value.

  
  proc getF(b: Bar): Foo = b.f
  getF(b).id = 10 # Error: 'getF(b).id' cannot be assigned to
  Run

  If you want a procedure that returns an assignable value, you can write it like so:

  
  proc getF(b: Bar): Foo = b.f  # returns a value
  proc mgetF(b: Bar): var Foo = b.f  # returns an assignable value
  
  assert getF(b).id == 5
  mgetF(b).id = 10
  assert getF(b).id == 10
  assert mgetF(b).id == 10
  Run

  This is the difference between items & mitems, and pairs & mpairs.

  https://nim-lang.org/docs/manual.html#procedures-var-return-type

  The following code snippet may help show what's going on under the hood with reference type assignments.

  
    type
      valObj = object
        value: int
      refObj = ref object
        direct: valObj
      indirectObj = object
        indirect: refObj
    
    let myVal = valObj(value: 10)
    let myRef = refObj(direct: myVal)
    let myIndirect = indirectObj(indirect: myRef)
    assert myVal.value == 10
    assert  myRef.direct.value == 10
    assert myIndirect.indirect.direct.value == 10
    
    myRef.direct.value = 20
    assert myVal.value == 10 # no change
    assert myRef.direct.value == 20  # changed!
    assert myIndirect.indirect.direct.value == 20  # changed!
    
    myIndirect.indirect.direct.value = 30
    assert myVal.value == 10  # no change
    assert myRef.direct.value == 30  # changed!
    assert myIndirect.indirect.direct.value == 30  # changed!
  Run

  For details about strictFuncs see: https://nim-lang.org/docs/manual_experimental.html#strict-funcs

---