Mirror of forum.nim-lang.org

31 :: Howto make a Interface like structure

• adrianveith (orginal) [2012-06-01T10:47:35+02:00] view original

  Hi,

  I am trying to build a Interface like structure and facing some problems. Here is what I have so far:

  
  
  
  type
    ITest = tuple[self:ref TObject,
      addxImpl: proc(self: ref TObject, v: Int),
      getxImpl: proc(self: ref TObject): string]
    
    TFoo = object of TObject
      data: Int
    TBar = object
      data: string
  
  
  proc addx(self: ref TFoo, v: Int) =
    self.data += v
  
  proc getx_TFoo(self: ref TFoo): string =
    return $self.data
  
  proc getIntf(self: ref TFoo): ITest =
    return cast[ITest]((self, addx, getx_TFoo))
  
  proc newTBar(): ref TBar =
    new(result)
    result.data = "test"
  
  proc addx_TBar(self: ref TBar, v: Int) =
    self.data &= $v
  
  proc getx_TBar(self: ref TBar): string =
    return self.data
  
  proc getIntf(self: ref TBar): ITest =
    return cast[ITest]((self, addx_TBar, getx_TBar))
  
  proc addx(self: ITest, v: Int) {.inline.} =
    self.addxImpl(self.self, v)
  proc getx(self: ITest): string {.inline.} =
    return self.getxImpl(self.self)
  
  var foo: ref TFoo
  new(foo)
  var test: ITest = foo.getIntf()
  test.addx(1)
  echo test.getx()
  
  var bar = newTBar()
  test = bar.getIntf()
  test.addx(1)
  echo test.getx()
  
  Run

  1. Is there a simpler solution ?
  2. I had to postfix the proc's with the name of the object, otherwise the getIntf proc can't distinguish between the implementation. Is there a way to get to specify which overloaded proc should be used ?
  3. I have to use a cast which is unsafe

---

• Araq (orginal) [2012-06-01T11:14:05+02:00] view original

  Some remarks in no particular order:

  • You can avoid the cast with a different (but annoying) code style:

    
      proc addx(self: ref TObject, v: Int) =
        # note: use the same signature
        var s = PFoo(self) # ugh, needs a PFoo type definition
        s.data += v
    Run

  • A better approach may be an "abstract base class" and multimethods.
  • Your tuple of procs idea is indeed a good one and I want to play with that approach as soon as closures work properly. The closures essentially hide the 'self' parameter and keep it typesafe. Unfortunately it's also not as memory efficient as a real interface because each closure in the tuple has its own 'self' pointer. Maybe a pragma will be introduced to enable 'self sharing'.
  • Should the tuple of procs idea do not work out too well in practice, a Go-like interface feature may be provided.

---

• adrianveith (orginal) [2012-06-01T12:22:14+02:00] view original

  I want to use Interfaces where there is no real object hierarchy, so an abstract base classes would break this idea.

  closures would make this far more elegant and a self sharing pragma would be perfect. But currently I don't care to much about memory for this use-case. When memory efficiency is a problem a structure like this, would be even better:

  
  
  type
    ITestProcs = tuple[
      addxImpl: proc(self: ref TObject, v: Int),
      getxImpl: proc(self: ref TObject): string]
    ITest = tuple[self:ref TObject, tab: ref ITestProcs]
  
  Run

  If there were not the problem with name ambiguity of the implementing procs, one could write a macro which generates the getIntf proc for a given object type and a interface tuple type

---