Mirror of forum.nim-lang.org

1258 :: Working around the lack of array covariance

• pminten (orginal) [2015-05-25T13:19:04+02:00] view original

  Hi, I'm trying to translate a simple reactive programming exercise to nim and am getting stuck on the fact that I can't pass a seq[SubtypeOfFoo] to a proc expecting seq[Foo]. The only way around it seems to be quite ugly.

  Here's what I'm trying to do.

  • My code implements a system who's basic unit is a cell.
  • All cells have values (simple ints).
  • There are two kinds of cells, input cells and compute cells (think = formula cells in a spreadsheet).
  • Input cells have a settable value, compute cells don't.
  • The value of a compute cell depends on a computation performed on other cells, which cells and what computation is defined when the cell is created.
  • When the value of an input cell is set all the values cells that directly or indirectly are updated.

  Slightly simplified, this is how my code looks from the outside:

  type
    Cell* = ref object of RootObj
      FValue: int
    InputCell* = ref object of Cell
    ComputeCell* = ref object of Cell
      compute: ComputeFunc
    ComputeFunc* = proc(vals: seq[int]): int
  
  proc createInput*(value: int): InputCell
  proc value*(c: Cell): int
  proc `value=`*(c: InputCell, value: int)
  proc createCompute*(inputs: seq[Cell], compute: ComputeFunc): ComputeCell
  Run

  What I'd like to do is execute this test:

  test "the value of a compute is determined by the value of the dependencies":
    let
      i1 = createInput(1)
      c1 = createCompute(@[i1], proc(vals: seq[int]): int = vals[0] + 1)
    check c1.value == 2
    i1.value = 2
    check c1.value == 3
  Run

  But it doesn't work because I'm passing a seq[InputCell] where a seq[Cell] is required.

  This works, but it's quite ugly and I kinda want a clean API:

  test "the value of a compute is determined by the value of the dependencies":
    let i1 = createInput(1)
    var cells: seq[Cell] = newSeq[Cell](1)
    cells[0] = i1
    let c1 = createCompute(cells, proc(vals: seq[int]): int = vals[0] + 1)
    check c1.value == 2
    i1.value = 2
    check c1.value == 3
  Run

  Is there a better way to do this that doesn't require me to assign array elements one at a time?

---

• Jehan (orginal) [2015-05-25T14:48:08+02:00] view original

  Array covariance is not typesafe to begin with and isn't necessary in your case. Simple use @[Cell i1] instead of @[i1] to tell the compiler you want a seq of Cell. @[Cell i1] is short for @[Cell(i1)] and works because the compiler will infer the type of an array from its first element.

---

• pminten (orginal) [2015-05-25T15:06:08+02:00] view original

  Works like a charm. Thank you.

---

• jibal (orginal) [2015-05-26T04:27:35+02:00] view original

  Jehan: Array covariance is not typesafe

  It is if the array isn't mutable.

---

• Varriount (orginal) [2015-05-26T05:13:23+02:00] view original

  I don't quite understand... Array covariance only works if the actual data type the array contains is a pointer/reference, right? Otherwise, for actual structures, you would have to somehow know the true size of the data type, so that index calculation worked correctly.

---

• Jehan (orginal) [2015-05-26T08:19:09+02:00] view original

  jibal: It is if the array isn't mutable.

  But Nim arrays are mutable. Array immutability is not really a very useful hypothetical.

---