Mirror of forum.nim-lang.org

5704 :: how to create a generic type with constraints?

• marks (orginal) [2019-12-18T10:49:11+01:00] view original

  I'm trying to port Python's difflib's sequence matcher to nim. I want to be able to compare any two sequences of the same types, not just strings.

  I have this type:

  type
    Diff[T] = object
      a: seq[T]
      b: seq[T]
      b2j: Table[T, seq[int]]
  Run

  How can I say that type T must support == and hash()?

---

• mratsim (orginal) [2019-12-18T12:12:56+01:00] view original

  If I didn't mess up my concept syntax

  type Diffable = concept x, y
    `==`(x, y) is bool
    hash(x) is Hash
  Run

  See: https://nim-lang.org/docs/manual_experimental.html#concepts

  And actual use cases:

  • Enqueueable concept: https://github.com/mratsim/weave/blob/a8f42d302e3d68f397374e9b14e964f647cb9afa/unused/channels/channels_mpsc_unbounded.nim#L8

  type
    Enqueueable = concept x, type T
      x is ptr
      x.next is Atomic[pointer]
  Run

  • IntrusiveStackable concept: https://github.com/mratsim/weave/blob/ed177fffaea6dbd6b7ddb648fc6e9cb302cae2ff/weave/memory/lookaside_lists.nim#L11-L14

  type
    IntrusiveStackable* = concept x, type T
      x is ptr
      x.next is T
  Run

  • StealableTask concept: https://github.com/mratsim/weave/blob/78c9033c1bbee5a8efde2d623d9e7cc8b9605f77/weave/datatypes/prell_deques.nim#L11

  type
    StealableTask* = concept task, var mutTask, type T
      ## task is a ptr object and has a next/prev field
      ## for intrusive doubly-linked list based deque
      task is ptr
      task.prev is T
      task.next is T
      # A task has a parent field
      task.parent is T
      # task has a "fn" field with the proc to run
      task.fn is proc (param: pointer) {.nimcall.}
  Run

  • NeuralNetwork Layer concept: https://github.com/mratsim/Arraymancer/blob/f06c43db379d1ef0160315162a45a8ab5bdb2b0d/src/nn_dsl/dsl_types.nim#L63-L68

  type
    TrainableLayer*[TT] = concept layer
      block:
        var trainable: false
        for field in fields(layer):
          trainable = trainable or (field is Variable[TT])
        trainable
  Run

  The last one is a bit hard, basically a concept must satisfy several properties, and that is checked by each statement returning true, so what I do there is creating a temporary bool called trainable in the concept and I check that recursively at least one field in the type or its subtypes is of Variable[TT] which would be something trainable in my framework. If there is at least one such field, it returns true and it's considered a TrainableLayer[TT].

---

• marks (orginal) [2019-12-18T13:27:11+01:00] view original

  Thanks. I think I'll do without concepts for now.

---

• geotre (orginal) [2019-12-18T16:38:38+01:00] view original

  These are great examples of concepts, I had no idea that last one would even be possible

---

• mashingan (orginal) [2019-12-18T16:40:23+01:00] view original

  Checking with compiles should enough

  when compiles(hash(a)): # a is the T object
    doWith(a)
  else:
    {.error: "need hash implementation of " & T.type.}
  Run

  It's checked during compile-time.

---