Mirror of forum.nim-lang.org

11065 :: Beginner question: mixing types in a sequence

• MisterDrgn (orginal) [2024-02-23T02:09:36+01:00] view original

  Hi, total newcomer here, so apologies if this isn't a clear question. As a basic experiment, I'm thinking about how to represent a graph, in which I have two types of objects: Branch: This object has a list of children. Leaf: This object is an endpoint with no children.

  This means that each branch's "children" field is a sequence of objects, where each object is either a branch of a leaf. So the question is how to represent this in Nim.

  1. Have a separate object type for branches and leaves. As far as I know, this is impossible because you can't have a sequence that holds a conjunction of two different types?
  2. Have a single "Node" object type for both branches and leaves. This type can have a "kind" field that indicates whether it's a branch or a leaf (or this could be inferred by the number of children). Here, the disadvantage is that, as far as I know, you can't overload procs on branches vs. leaves, since they have the same type. Is that correct? You can only overload procs based on an item's type, not based on some other arbitrary information about the item?
  3. Do 2), but forget about proc overloading. If I want a proc to handle branches and leaves differently, I'll simply have to check the kinds within the body of the proc.

  Does this make sense? Is 3) the only viable option in Nim, or am I missing something?

  Thank you.

---

• shirleyquirk (orginal) [2024-02-23T10:20:46+01:00] view original

  i'd recommend you read through the nim tutorial and manual, the sections on variants in the tutorial and manual in particular.

  type NodeKind = enum
    Leaf,
    Branch
  type Node = object
    case kind: Nodekind
    of Leaf:
      value: int # or whatever
    of Branch:
      kids: seq[Node]
  Run

  is very typical Nim code, and how Nim itself is implemented.

  to handle variants in a proc you also use the case statement

  import std/[sequtils]
  
  proc nd(i:int):Node = Node(kind: Leaf, value: i)
  proc nd(n:Node):Node = n
  proc nd(x:varargs[Node]):Node = Node(kind: Branch, kids: @x)
  
  proc sum(node: Node):int =
    case node.kind
    of Leaf:
      return node.value
    of Branch:
      return foldl(node.kids,a+sum(b),0)
  
  let n = nd(nd(3),nd(4),nd(nd(5),nd(6)))
  
  assert sum(n)==18
  Run

---

• MisterDrgn (orginal) [2024-02-23T14:34:25+01:00] view original

  Thanks for the reply. I came across this last night, and it makes a lot of sense.

---