Distinct for indices, is it good library Api?

[b3liever]

Hi and merry Christmas,

I was trying to port [petagraph](https://github.com/petgraph/petgraph) rust 
library to nim and although I made some 
[progress](https://gist.github.com/b3liever/de2d4e2267b13832f7d52f10ba3140fe) I 
am struggling with some fundamental decisions.

for example, when adding a node in the graph, it returns the index:
    
    
    var graph: Graph[string, float]
    let nodeA = graph.addNode("a")
    let nodeB = graph.addNode("b")
    let nodeC = graph.addNode("c")
    let nodeD = graph.addNode("d")
    let nodeE = graph.addNode("e")
    let nodeF = graph.addNode("f")
    let nodeG = graph.addNode("g")
    let nodeH = graph.addNode("h")
    
    # Also returns the edge index when adding an edge, not sure if its useful
    let edge1 = graph.addEdge(nodeA, nodeB, 1.0)
    
    Run

These indices are `distinct` types like so:
    
    
    type
      IndexType = int
      NodeIndex = distinct IndexType
      EdgeIndex = distinct IndexType
    
    Run

That allows to have array element access syntax for nodes and edges:
    
    
    proc `[]`*[N, E](self: Graph[N, E], a: NodeIndex): N =
      ## Access the weight for node `a`.
      self.nodes[int(a)].weight
    
    proc `[]`*[N, E](self: Graph[N, E], e: EdgeIndex): E =
      ## Access the weight for edge `e`.
      self.edges[int(e)].weight
    
    # works like so:
    echo graph[edge1] # 1.0
    echo graph[nodeA] # "a"
    
    Run

And this was the only benefit I think there is with `distinct` indices, 
consider this code:
    
    
    import graph, sequtils
    let graph2 = fromEdges[int, int](mapLiterals(@[
       (0, 1), (0, 2), (0, 3),
       (1, 2), (1, 3),
       (2, 3)], NodeIndex))
    
    Run

becomes tiresome to write, since everything needs to converted to the correct 
`IndexType` subtype. Also the internal code is littered with 
`self.nodes[int(nix)]`. My question is does it worth it, or should I just use 
int everywhere?