标签：nim和面向对象   nim   面向对象编程   

Nim and OO

作者：Roads less Taken

A blend of programming, boats and life.

时间：2014,10,29

Nim is presented as an imperative language. And yes, it has some of its roots in the Pascal line of languages, but it also has a set of powerful abstraction mechanisms making it very suitable for object oriented programming. And when I write “object oriented” I am referring to a broader flexible sense of OO in which objects can be formulated with attached behavior, polymorphism between different objects, some kind of reuse model of code (inheritance etc) and some type of dynamic dispatch.

nim作为一种命令语言呈现。是的，它有一些根源在pascal语言中，但是它有一套强大的抽象机制使它非常适合面向对象编程。当我写“object oriented(面向对象)”的时候，我指的是一个更广阔灵活度的OO，可以通过附加行为规划对象，不同对象之间存在多态性，某种代码重用模型（继承等）和某种类型的动态调度。

Since I am a long time Smalltalker that is my main reference for “good OO” and not the … monstrous OO often seen in Java or C++. Its hard to explain the differences, but let me just say that OO in Smalltalk is elegant and natural, very much like in Ruby or Python - but ever so more streamlined. Smalltalk is a dynamically strongly typed reflective language with a heavily closure based style.

既然我是一个长时间的smalltalker，所以我提到的主要是“good OO(好对象)”并不是。。。经常在java或者c++中见到的丑陋的对象。它很难解释不同，但是我只说smalltalk中的面向对象在是优雅和自然的，非常类似与ruby或者python中的面向对象,但是更精简。smalltalk是一个动态的强类型反射语言带有一个大量基于闭包类型。

In this article I will try to make “sense” out of how to do OO in Nim.

在这篇文章中，我将尝试面向对象怎样在nim中有意义。

OO in Smalltalk

1
2

fn(a, b)
a.fn(b)

Having both proc overloading and the Uniform Function Call Syntax in combination with theneat modules system where one module can define procs using types from other modules (pretty obvious you can do that) - then we already can do “OO looking code” in a simpler fashion. For example we can easily add a reversed() method to the type string that returns a new string with characters reversed.

具有过程重载和统一函数调用语法结合整齐的模块系统，一个模块可以使用来自其他模块的类型定义过程（很明显你可以做到它）-然后我们已经可以以一种更简单的方式实现“OO looking code”。例如，我们可以很容易的为字符串类型添加一个reversed()方法，返回一个新的反序字符串。

First, lets just verify that string doesn’t already have it. I use Aporia and I have turned on“Enable suggest feature” in Preferences, then it tries to help me:

首先，让我们验证字符串没有reversed()方法。我使用Aporia并且我已经在参数选择中打开了“启用建议特征”，然后它试图帮助我：

…so nothing there right now. Let’s hack. In the beginning below we see that reversed()already exists for openarray, which means both array and seq types. Then we add it for string:

...所以现在什么都没有。让我们破解。在下面开始我们看到reversed()已经存在于在openarray中了，它意味着数组和序列类型。下面我们我们为字符串添加它：

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# Some data to play with
var anArray = [1, 2, 3, 4]
var aSequence = @["a", "b", "c"]

# Aha, in module algorithm.nim we already have reversed() for openarray//在algorithm模型中我们已经有了openarray的reversed()方法
# which is the type covering both array and seq.   //openarray类型包含数组和序列

# Hehe, we can import down here too if we like    //我们可以导入algorithm模块
import algorithm

# And yes, reversed works for those guys
echo(anArray.reversed())
echo(aSequence.reversed())

# But it doesn‘t work for string, let‘s add it      //reversed()不能作用与字符串，让我们添加它
proc reversed(s: string) :string =
  ## Shamefully ripped from algorithm.nim for openarrays
  result = s
  var x = 0
  var y = s.high
  while x < y:
    swap(result[x], result[y])
    dec(y)
    inc(x)

# Testing it, works for literals
echo "abc".reversed

# Works for vars too of course :)      //当然变量也能工作
var test = "Goran"
echo(test)
echo(test.reversed)

# And yes, not destructive. "reverse" (no d) would be destructive.
echo(test)

…using Aporia we can actually immediately see right after we wrote that proc, that the compiler picked it up and offered it as a suggestion when we started typing in test code:

...使用Aporia，实际上在我们写了那个过程后我们可以立即看到它，编译器捕获它并提供它作为一个建议，当我们开始编写test代码的时候：

Compile and run:

1
2
3
4
5
6
7
8

gokr@yoda:~$ nim c -r --verbosity:0 testreversed.nim
@[4, 3, 2, 1]
@[c, b, a]
cba
Goran
naroG
Goran
gokr@yoda:~$

Funny sidenote: “G?ran” didn’t work so well… UTF8 strikes! But this is fully natural given our non-UTF8 aware implementation, we end up reversing the two UTF8 bytes representing “?”…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# We create a FreakInt which behaves like an int, but is its own type.
# We can not pass a FreakInt when someone wants an int - and vice versa.
# This also means that all operators and procs defined for ints, do NOT
# apply for a FreakInt - they are dumb as hell basically.#我们创建了一个FreakInt类型，它的行为像一个int，但是它自己的类型。#当我们需要int类型的时候，不能传递一个FrealInt类型，反之亦然。
#这意味着所有的操作符和过程都是为int定义，不能应用于一个FreakInt-它们基本上蠢得要命

type
  FreakInt = distinct int

# Ok, so we borrow multiplication by an int       //所以我们通过一个int借乘法
proc `*` (x: FreakInt, y: int): FreakInt {.borrow.}

# Let‘s override `+`: FreakInt also multiplies by 2...   //让我们重写`+`：FreakInt乘2
proc `+` (x, y: FreakInt): FreakInt =
  FreakInt((int(x) + int(y)) * 2)

# Can we go down the rabbit hole? What happens with a distinct   //用一个distinct类型定义一个distinct类型会发生什么？
# type of a distinct type?
type
  UltraFreak = distinct FreakInt

# Ok, so we borrow `*` and `+` from FreakInt?    //‘*‘和‘+‘是从FreakInt来的吗？
# No, it turns out it borrows from the base type int - this is NOT inheritance.  //不，事实证明它来自基本的int类型，这不是继承
proc `+` (x, y: UltraFreak): UltraFreak {.borrow.} 
proc `*` (x: UltraFreak, y: int): UltraFreak {.borrow.}

# UltraFreak ints multiply by 10 when doing subtraction...  
proc `-` (x, y: UltraFreak): UltraFreak =
  UltraFreak((int(x) - int(y)) * 10)

# Hold onto hat..
var
  i: int = 5
  f: FreakInt = 6.FreakInt # Conversion, same as FreakInt(6)
  u: UltraFreak = 7.UltraFreak

# Did FreakInt manage to borrow `*` from int? yes     //FreakInt从int成功借到`int`了吗？
assert(int(f * i) == 30)

# Did FreakInt manage to override `+`? yes     
assert(int(f + f) == 24)

# Did UltraFreak manage to borrow `+` from... what?
# Ok, from int, not FreakInt!
assert(int(u + u) == 14)

# Also from int, not FreakInt!
assert(int(u * i) == 35)

# But we did get our own `-`, right? Yes we did.
assert(int(u - 3.UltraFreak) == 40)

1
2

type
  Person: tuple[name: string, age: int]

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# Playing with ref, enum and assignment

type
  LightImpl = enum LiGreen, LiYellow, LiRed
  Light = ref LightImpl

# Convenience method, good style
proc newLight(): Light = new(result)

var
  # This is a variable allocated in the stackframe  #这是在栈上分配的一个变量
  light: LightImpl
  # This allocates and initializes a LightImpl on the heap   #这种是在堆上分配和初始化一个LightImpl,并且使lightHolder引用它。如果你分开初始化，
  # and makes lightHolder refer to it. If you do initialization  #你可以使用new(lightHolder)。
  # separately you can also use `new(lightHolder)`
  lightHolder = new(LightImpl)
  # Better style to call a proc to do it.   #更好的方式是调用一个过程来做
  lightHolder2 = newLight()

# Dereference to get the Light value, check it has the default value  #解引用得到Light的值，检查它有的默认值
assert(lightHolder[] == LiGreen)

# Set the local stackframe allocated Light to a different value   #设置本地栈框架给light分配一个不同的值
light = LiYellow

# Assignment copies the bits of light to the Light on the heap    #赋值语句复制light位给在堆中的Light
# You need to use `[]` dereferencing here.                        #这里你需要使用`[]`解引用
lightHolder[] = light

# Should be yellow now                                            #现在应该是yellow吗
assert(lightHolder[] == LiYellow)

# Let‘s modify the local stackframe light                         #让我们修改本地栈框架中的light
light = LiRed

# Make sure the Light on the heap is still yellow                #确保堆中的Light仍然是yellow
assert(lightHolder[] == LiYellow)

Remark

Since I have been working primarily in Java, C# and Smalltalk the last 20 years (ouch) I have gotten used to variables almost always being references to objects, and objects almost always being allocated on the heap. Nim has value types, and then ref and ptr is used to create reference types pointing at them. I am not a language designer though - perhaps one can express it using more precise words.

过去的20年我的主要工作是在Java，C#以及Smalltalk，我已经习惯了变量几乎总是被对象引用，和对象几乎都是在堆上分配的。Nim有值类型，然后引用和指针被用来创建引用类型指向它们。我不是一个语言设计者-也许有人可以用更精确的语言表达它。

Proc variables are automatically allocated in the stack frame, as usual. This is also true of refvariables, but for those we only allocate the actual pointer bits there. But where does it point? This is where an allocation step comes into play - using new(). Calling new() with a ref variable as argument, will allocate the type that the ref variable refers to on the heap, and then set our ref variable to point there. Obviously you can also explicitly pass the type that the ref refers to (in the example code LightImpl) but that makes the code more brittle and less encapsulated.

跟平常一样，过程变量会在栈框架中自动分配。引用变量也是一样，但是对于那些我们只分配实际的指针位。但是它指向哪里呢？这是一个分配步骤进场的地方-使用new().用引用变量作为参数调用new（），将在堆中分配引用变量指向的类型，然后设置我们的引用变量指向这里。显然你可以显示的传递引用指向的类型（例子代码中的LightImpl），但是那样使得代码很脆弱和更少的封装性。

I think the greater flexibility of Nim, where we can choose to allocate values or references to values has benefits in more complex scenarios - and definitely for performance. It seems fairly well “embedded” in nice mechanisms so that general application level OO code doesn’t suffer too much from this “complication”.

我认为nim更大的灵活性是，我们可以选择分配值或者引用值有好处在更复杂的情况下-并且具有更高的性能。这似乎是相当好的“嵌入式”机制，以至于通用的应用程序层面的面向对象代码并没有从这样的混乱变糟。

Objects

Ah, finally! But this is not your dad’s Java objects, or your granddad’s Smalltalk objects. First of all, we don’t have “classes” - in Nim that term is not really used. Instead we talk about an object type.

最后的！但是这不是你父亲的Java对象，或者你爷爷的Smalltalk对象。首先，我们没有“classes”-在Nim中不是真的使用，相反我们讨论一个对象类型。

An object is similar to a tuple, but it knows its type at runtime and we can decide which members we want to be visible outside the containing module. We can also inherit from an existing object type, single inheritance. Let’s hack some code:

一个对象类似于一个元组，但是它知道它的运行时类型，并且我们可以决定我们要在包含模块外可见的成员。我们也可以从已有的对象类型继承，单一继承。让我们看一些代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

# Distinct types seem useful for units, not essential  #distinct类型对于units看起来有用，对于这个例子代码并不是必不可少的，但是无论如何，让我们使用它
# for this sample code, but whatever, let‘s use them.
type
  Dollar* = distinct float
  Kg* = distinct float

# We can define $ for Dollars too
proc `$`*(x: Dollar) :string =
  $x.float

# Let‘s borrow `==` for simpler code
proc `==`*(x, y: Dollar) :bool {.borrow.}


# Let‘s create a base class for fruits with country   #让我们为fruits创建一个基础类有原产地和美元价格。注意：我们通常从RootObj继承，
# of origin and a price in dollar. Note that we typically   #它基本上是像Smalltalk和Java中的对象类。
# inherit from RootObj which is basically like the Object   #注意：我们将Fruit声明为一个引用类型
# class in both Smalltalk and Java.
# Also note that we declare Fruit to be a ref type.
type
  Fruit* = ref object of RootObj
    origin*: string
    price*: Dollar

# We like to deal with different sizes of bananas  #我们想要处理有不同大小的bananas，所以我们创建一个子类型并且添加一个size成员
# so we create a subtype and add a size member.
type
  Banana* = ref object of Fruit
    size*: int

# And pumpkins can have very different weights   #pumpkins可以有不同的重量
type
  Pumpkin* = ref object of Fruit
    weight*: Kg
  # A very big one
  BigPumpkin* = ref object of Pumpkin

# And... can we also make a non ref subtype of  #我们也能创建一个引用类型的非引用子类型吗，看起来如此。引用它本身的属性是不会被继承的。
# a ref subtype, seems so. The ref property itself is
# thus not inherited.
type
  NonRefSubBanana = object of Banana

# Base reduction is just zero, override in subtypes.   #基础reduction仅仅是零，在子类型中重写它。创建这样一个方法是要看看我们是否可以用一个过程
# Made this a method to see if we can override it with a proc.   #重写方法
method reduction*(self) :Dollar =
  Dollar(0)

# Override with a proc. Humpty dumpty, should bind statically   #用一个过程重写。应该静态绑定Bananas，否则调用前一个方法。
# for Bananas, otherwise call the one above.
proc reduction*(self: Banana) :Dollar =
  Dollar(9)

# Our base implementation just makes sure we round off    #我们的基础实现仅仅是确保我们舍入到最近的分和减去任何reduction。
# to nearest cent and subtracts any reduction.
import math
proc calcPriceProc*(self) :Dollar =
  Dollar(round(self.price.float * 100)/100 - self.reduction().float)

# Lets implement it smarter for Pumpkins. Here we convert    #让我们对于Pumpkins更聪明的实现它。这里我们转换为一个Fruit为了实现调用”super“
# to a Fruit in order to call the "super" implementation.
proc calcPriceProc*(self: Pumpkin) :Dollar =
  Dollar(calcPriceProc(Fruit(self)).float * self.weight.float)

# BigPumpkin - 1000 bucks! Take it or leave it!     #采取它或者离开它。这是重写基础过程的一个方法
# This is a method overriding the base proc
method calcPriceProc*(self: BigPumpkin) :Dollar =
  Dollar(1000)


# A base implementation too, but as a method instead of a proc.     #同样是一个基础实现，但是作为一个方法而不是一个过程。
method calcPriceMethod*(self: Fruit) :Dollar =
  Dollar(round(self.price.float * 100)/100 - self.reduction().float)

# And a method similarly for Pumpkins, hum...
# We can‘t use the type conversion "super call" technique - because methods  #类似于Pumpkins的一个方法，
# dispatch on runtime type - so how can we call the method above???  #我们不能使用类型转换”super call“技术-因为方法调用运行时类型-所以我们怎样
# We can‘t, fall back on calling the base proc instead.               #调用上面的方法？？？ 我们不能，反而依赖于调用基础的过程。
method calcPriceMethod*(self: Pumpkin) :Dollar =
  Dollar(calcPriceProc(Fruit(self)).float * self.weight.float)

Phew! So the above little fruit library sets up some trivial inheritance and adds some procs and methods to these object types which we want to play with to see how the inheritance works. Now, the following code uses the above library:

所以上面的fruit库建立了一些平常的继承和添加了一些过程和方法对这些对象类型，我们想看看这些对象类型的继承是如何工作的。现在，下面的代码使用上面的库：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import fruit

# Create some fruits, normally one would not use constructor  #创建一些fruits，通常不会像这样使用构造器语法，而是调用在fruit模块中一个过程
# syntax like this, instead call a proc in the fruit module   #让它为我们做，封装。
# that does it for us, encapsulation.
var p = Pumpkin(origin: "Africa", price: 10.00111.Dollar, weight: 5.2.Kg)
var b = Banana(origin: "Liberia", price: 20.00222.Dollar)

var bp = BigPumpkin(origin: "Africa", price: 10.Dollar, weight: 15.Kg)

# BigPumpkins have a method overriding the base proc, it works!  #BigPumpkins有一个重写基础过程的方法，它有效工作！
assert(bp.calcPriceProc() == 1000.Dollar)

# Works for Banana, uses Fruit base proc, we see it rounds to cents  #工作与Banana，使用Fruit基础过程，我们看到它舍入到分，它也为Bananas做了一个对于
# and it also then make a self call to reduction() for Bananas.      #reduction()的self调用。
assert(b.calcPriceProc() == 11.0.Dollar)

# Works for Pumpkin, static binding. Rounds to cents (the super call)   #工作与Pumpkin，静态绑定。舍入到分（调用super）并且与重量相乘，没有reduction，正确
# and multiplies with weight. No reduction, correct.
assert(p.calcPriceProc() == 52.0.Dollar)

# What happens in a proc generalized for Fruits? Type info is lost so   #在一个过程中推广Fruits会发生什么？类型信息丢失，所以静态绑定将会绑定到基础实现
# static binding will bind to base implementation regardless of what x is.  #不管x是什么
proc testingProcs(x: Fruit) :Dollar =
  # Here the type of x is Fruit
  x.calcPriceProc()

# Lets call the above proc and see...               #让我们调用上面的过程看看。。。
# Oops, the self send reduction() misses that its a Banana!   
assert(testingProcs(b) == 20.Dollar) # Should be 11
# Oops, the override of calcPriceProc() for Pumpkins is also missed!  #为Pumpkins重写的calcPriceProc()也丢失了！
assert(testingProcs(p) == 10.0.Dollar) # Should be 52

# But with generics it works just fine... We can also constrain it to
# only accept Banana and Pumpkin.   #但是使用泛型它工作的很好。。。我们也可以限制它只接受Banana和Pumpkin
proc testingProcsGeneric[T: Banana|Pumpkin](x: T) :Dollar =
  # Here Nim will produce multiple variations of this method, for both Banana  #这里nim将产生这个方法的多个变形，所以类型信息不会丢失。
  # and Pumpkins (call sites below), so type information is not lost.
  # It should call the correct proc.
  x.calcPriceProc()

# All good with generics
assert(testingProcsGeneric(b) == 11.0.Dollar)
assert(testingProcsGeneric(p) == 52.0.Dollar)

# If we call a method the type of x doesn‘t matter, its the type of the object  #如果我们调用一个方法类型x无关紧要，其类型对象本身的价值。
# itself that counts.
proc testingMethods(x: Fruit) :Dollar =
  # Here we will dispatch dynamically    #这里我们将动态调用
  x.calcPriceMethod()

# All good... or??? Oops, the reduction for Bananas is lost!   #所有的都很好。。。或者？？？Bananas的reduction（）丢失了！
assert(testingMethods(b) == 20.0.Dollar) # Should be 11
# The override for Pumpkin works fine    #为Pumpkin重写的工作的很好
assert(testingMethods(p) == 52.0.Dollar)

echo "All good, well, or at least we got what the comments said."

Did you follow all that? Really? Then explain it to me! :)

你仅仅跟随了吗？真的？为我解释它!:)

Basically, mixing procs and methods … is tricksy.

So let’s shorten, remove comments, regroup code into “classes” and only use methods. To solve the “super call” we throw in a template so that we can reuse that code in two different methods. Not the same, but ok:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import math

# Dollars and Kgs
type
  Dollar* = distinct float
  Kg* = distinct float

proc `$`*(x: Dollar) :string =
  $x.float

proc `==`*(x, y: Dollar) :bool {.borrow.}


# Fruit class
type
  Fruit* = ref object of RootObj
    origin*: string
    price*: Dollar

method reduction*(self: Fruit) :Dollar =
  Dollar(0)

# Code broken out in a template for reuse, since super call doesn‘t
# fly with methods yet.
template basePrice(): Dollar =
  Dollar(round(self.price.float * 100)/100 - self.reduction().float)

method calcPrice*(self: Fruit): Dollar =
  # Use template, zero cost
  basePrice()


# Banana class
type
  Banana* = ref object of Fruit
    size*: int

method reduction*(self: Banana): Dollar =
  Dollar(9)


# Pumpkin
type
  Pumpkin* = ref object of Fruit
    weight*: Kg

method calcPrice*(self: Pumpkin) :Dollar =
  # Use template, zero cost
  Dollar(basePrice().float * self.weight.float)


# BigPumpkin
type
  BigPumpkin* = ref object of Pumpkin

method calcPrice*(self: BigPumpkin) :Dollar =
  Dollar(1000)

And the code testing it:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import fruit

var p = Pumpkin(origin: "Africa", price: 10.00111.Dollar, weight: 5.2.Kg)
var b = Banana(origin: "Liberia", price: 20.00222.Dollar)
var bp = BigPumpkin(origin: "Africa", price: 10.Dollar, weight: 15.Kg)

assert(bp.calcPrice() == 1000.Dollar)
assert(b.calcPrice() == 11.0.Dollar)
assert(p.calcPrice() == 52.0.Dollar)

# What happens in a proc generalized for Fruits? Type info is lost
# but since we now use only methods, it doesn‘t matter
proc testing(x: Fruit) :Dollar =
  x.calcPrice()

assert(testing(b) == 11.Dollar)
assert(testing(p) == 52.0.Dollar)
assert(testing(bp) == 1000.Dollar)

echo "All good with only methods."

What I learned from the above:

我从上面学到的：

1 Single inheritance works fine in Nim, no surprises really. Sure, procs and methods are defined “on their own” but there is no practical difference.

单继承在nim中工作的很好，没有惊喜，真的。当然，过程和方法被定义为自己的，但没有实际的不同。

2 Procs bind statically and calling a “super” proc is easy using type conversion. But… if the super method calls other methods… ouch! Type info lost! Better to use templates or similar as above.

使用类型转换过程静态绑定和调用一个”super“过程很容易的。但是...如果super方法调用其他方法...！类型信息丢失！更好的是使用模版或者与类似上面。

3 If we don’t use generics but instead use base types (like Fruit) for arguments, we will “lose” type information, and potentially we “miss” calling our overrides! Not a surprise to a hardcore static guy, but… as a dynamic typing dude - this is a gotcha! Using methods only of course avoids that issue.

对于参数如果我们不使用泛型而是使用基础类型（例如Fruit），我们将丢失类型信息，以及我们可能错过调用我们的重写方法。对于一个静态的类型这并不惊讶，但是作为一个动态类型-这是个问题！仅使用方法当然避免的这个问题。

4 Methods and procs can be mixed, but here there be dragons. I think. 

方法和过程可以混合，但是这里有问题。我认为。

5 If we use methods we currently can’t call a “super” method. Workaround today is to factor out the base implementation, for example in a template, as done above. UPDATE: See partIV about this.

如果我们使用方法，我们目前不能调用一个”super“方法。今天的解决方法是因素的基础实现，例如在一个模版里，如上面所做的那样。更新：See part IV about this。

6 If we use procs only and apply generics (I did but didn’t bother including that code), it works perfectly fine too in this example. But as noted, do not use type conversion to a base type to do super calls, unless you are sure what you are doing. :)

如果我们仅使用过程和泛型（我实现了但是这不包括那个代码），在这例子中它也能工作的很好。但是要注意的是，不要使用类型转换为一个基类型为了super调用，除非你确定你在做什么。

7 If you have several classes like this in the same module, take care of the order of procs - make sure your overrides are defined before their uses. Otherwise you can easily end up calling a base implementation, just because the compiler hasn’t seen the override definition yet!

如果在相同的模块中你有几个类似这样的类，小心过程的顺序-确保你的重写在使用它们之前已经定义。否则你可以很容易的以调用一个基础实现而结束，仅仅是因为编译器没有看到重写的定义！

Remark

Phew. In summary I would say the OO features are mostly there. Super calls (for both procs and methods I would say) is evidently a “hole” in the language, I think it needs some kind of solution. But coding and testing is a very nice experience, its not that hard to get into it. But I would say it will take some practice before you know what routes are available for OO in Nim.

总之，我想说的面向对象的特征主要在这里。super调用（我说的是对于过程和方法）在语言中明显的是一个”hole“。我认为它需要某种解决办法。但是编码和测试是一个很好的经验，它不是很难进去。但是我想说在你知道什么路线可用于nim中面向对象之前它需要一些练习。

Conclusion

I have only begun discovering Nim so I have yet to see how OO works in a larger Nim codebase. I also haven’t really explored lambdas and several of the datatypes yet, nor macros and templates and lots of other things. But I feel confident that Nim can do OO code quite well.

我只是开始发现nim所以我还没有看到面向对象怎样工作在一个更大的nim代码库中。我也没有真正的探索lambdas和几种数据类型呢，还有宏和模版以及许多其他的东西。但是我很有信心nim可以将面向对象代码做的很好。

Go Nim!

向nim出发！

Posted by G?ran Krampe Oct 29th, 2014  Languages, Nim, Nimrod, OOP, Object orientation, Programming

文章链接:

Nim Socket Server

Ubuntu Just Works

nim和面向对象(一)

标签：nim和面向对象   nim   面向对象编程   

原文地址：http://blog.csdn.net/dajiadexiaocao/article/details/46537757