Methods

Procedures always use static dispatch. Methods use dynamic dispatch. For dynamic dispatch to work on an object it should be a reference type.

  1. type
  2.   Expression = ref object of RootObj ## abstract base class for an expression
  3.   Literal = ref object of Expression
  4.     x: int
  5.   PlusExpr = ref object of Expression
  6.     a, b: Expression
  8. method eval(e: Expression): int {.base.} =
  9.   # override this base method
  10.   raise newException(CatchableError, "Method without implementation override")
  12. method eval(e: Literal): int = return e.x
  14. method eval(e: PlusExpr): int =
  15.   # watch out: relies on dynamic binding
  16.   result = eval(e.a) + eval(e.b)
  18. proc newLit(x: int): Literal =
  19.   new(result)
  20.   result.x = x
  22. proc newPlus(a, b: Expression): PlusExpr =
  23.   new(result)
  24.   result.a = a
  25.   result.b = b
  27. echo eval(newPlus(newPlus(newLit(1), newLit(2)), newLit(4)))

In the example the constructors newLit and newPlus are procs because they should use static binding, but eval is a method because it requires dynamic binding.

As can be seen in the example, base methods have to be annotated with the base pragma. The base pragma also acts as a reminder for the programmer that a base method m is used as the foundation to determine all the effects that a call to m might cause.

Note: Compile-time execution is not (yet) supported for methods.

Note: Starting from Nim 0.20, generic methods are deprecated.