Zero-overhead interface exploration in Nim language
Tags: nim, interface
Published: 2020-07-06 15:22:37

[Nim](https://nim-lang.org/) is a statically typed compiled systems programming language. It is efficient, expressive and elegant. I really enjoy coding Nim.

However, when it comes to `interface`, Nim lacks a built-in `interface` making it hard to implement dependency injection pattern.

In spite of lack of `interface` at the syntactic level, we still have some ways to simulate `interface` . It may be not suitable for general purposes. But it works well in terms of implementing dependency injection pattern.

Before starting to read, you should install [shene](https://github.com/xflywind/shene) .

## Function pointers

A function pointer points to a function declaration. 

First we create a new class declaration with all function declarations that we need.  

```nim
type
  Animal* = object
    id: int
    sleepImpl: proc (a: Animal) {.nimcall, gcsafe.}
    barkImpl: proc (a: Animal, b: int, c: int): string {.nimcall, gcsafe.}
    danceImpl: proc (a: Animal, b: string): string {.nimcall, gcsafe.}
    
  People* = object
    pet: Animal
```

Second we write function definitions for `Animal` class. Then we assign function pointers to corresponding attributes.  Next, we construct People object and pass an Animal instance to it. Finally, we call `barkImpl` and pass parameters to it. Now, we get the right result: “1340”.

```nim
proc sleep(a: Animal) =
  discard

proc bark(a: Animal, b: int, c: int): string =
  result = $(a.id + b + c)

proc dance(a: Animal, b: string): string = 
  result = b

proc newAnimal*(id: int): Animal =
  result.id = 1314
  result.sleepImpl = sleep
  result.barkImpl = bark
  result.danceImpl = dance

let people = People(pet: newAnimal(12))
doAssert people.pet.barkImpl(people.pet, 12, 14) == "1340"
```

This is pretty neat except that we specify `people.pet` twice. Let’s deduplicate it. 

```nim
import shene/ucall


let people = People(pet: newAnimal(12))
doAssert people.pet.ucall(barkImpl, 12, 14) == "1340"
```

Well, better now. Let’s look at the advantages. It does implement late binding and makes codes extensible. We only need to declare Animal class and expose it to users. Users can implement their own function definitions for Animal class and assign function pointers to the attributes of Animal’s instance.

However, users can’t extend the data of the Animal instance. Users’ function definitions are only allowed to use the `id` attribute which is fixed at the declaration time of Animal class. No more attributes can be added.

Let’s look at another way. This way decouples `impl` and `data` and makes data extension easier. You can extend data object at your will.

### Decouple `impl` and `data`

`Impl` represents `Impl Class` and `data` stands for `Data Class`. `Impl Class` supplies all interfaces which should be satisfied. `Data Class` supplies all attributes that users need and it can be extended by users. They both support inheritance.

```
# shene.nim
type
  Must*[U: object; T: object | ref object] = object 
    impl*: U
    data*: T
```

#### Impl Class

We define function pointers just like before, but now the first parameter of function declarations should be generics type. We should only define function pointers without any other attributes.

```
import shene/mcall


type
  Animal*[T] = object of RootObj
    sleepImpl: proc (a: T) {.nimcall, gcsafe.}
    barkImpl: proc (a: var T, b: int, c: int): string {.nimcall, gcsafe.}
    danceImpl: proc (a: T, b: string): string {.nimcall, gcsafe.}
```

#### Data Class

Data Class contains all user-defined attributes. You can add data attributes by means of inheritance. But be careful, now we need `Must[Animal[Cat], Cat]` type as the type of our object which is passed to `People` object. `shene` supplies `must(Animal, Dog)` which is a helper templates to simplify type declaration. It also overloads `dot operator` and makes assignment easier.   

```
# If class is ref object, user must `new Must.data` or `init Must`.
type
  Dog = object
    id: string
    did: int
    name: string


proc bark(d: var Dog, b: int, c: int): string =
  doAssert d.name == "OK"
  d.did = 777
  doAssert d.did == 777
  d.id = "First"
  doAssert d.id == "First"

# must(Impl class, Data class)
proc newDog(): must(Animal, Dog) =
  result.name = "OK"
  result.did = 12
  result.barkImpl = bark
```

#### Oriented-User Class

Regarding People class, we need additional generics type. `must(Animal, T)` is the helper templates for `Must[Animal[T], T]`. 

```
type
  People*[T] = object
    pet: must(Animal, T)
```

#### Usage

Its usage is simple. We only need to add additional generics type. There is little difference compared to before.

```
var d = newDog()
var p1 = People[Dog](pet: d)
discard p1.pet.call(barkImpl, 13, 14)
```
#### Other tips
If you need dynamic dispatch, you can also use multi-methods. 

#### A better solution

Thanks jyapayne, we have a better solution:
```nim

type
  Animal* = concept a
    a.id is int
    a.sleep()
    a.bark(int, int) is string
    a.dance(string) is string
  
  People*[T: Animal] = object
    pet: T
  
  # User defined type
  Dog* = object
    id: int

# User defined procs

proc sleep*(d: Dog) =
  discard

proc bark*(d: Dog, b: int, c: int): string =
  result = $(d.id + b + c)

proc dance*(d: Dog, b: string): string =
  result = b

proc newDog*(id: int): Dog =
  result.id = 1314


proc pay[T](p: People[T]) =
  doAssert p.pet.bark(12, 14) == "1340"
  doAssert p.pet.dance("dancing") == "dancing"

let d = newDog(12)
pay[Dog](People[Dog](pet: d))
```
from https://forum.nim-lang.org/t/6523

## Conclusion

Using function pointers, we can simulate `interface` . We improve the extensibility and maintainability of codebase. Although we still need a better way to represents `interface`, let’s take this as our first step.

Last but not least. Nim is a magic programming language. It is still young and needs more attentions. Explore it and you may fall in love with Nim.