循序渐进学Boo - 知识篇

Boo官方网站上提供了详细的介绍与实例（尽管有小部分内容现已过时，但大家还是可以学习到Boo的语法特性）：
1.Boo Primer
2.Language Guide
如果大家希望能深入了解到Boo的语法特性，强烈建议大家阅读Steve Donovan写的The Book of Boo - A TiddlyWiki about Boo。

在大家阅读完上述链接的内容后，本文着重结合"从一个小实例开始 - Boo开篇"中的实例向大家介绍Boo相对重要的特性，为后续文章的阅读奠定基础。

首先要强调的是，编写Boo代码需要遵循以下的代码结构顺序：
module docstring
namespace declaration
import statements
module members: class/enum/def declarations
main code executed when script is run
assembly attributes
下面是个例子：

""" module docstring """

namespace My.NameSpace # optional namespace declaration



import System # import statements

# followed by the Members of this module (classes, methods, etc.)

class Heater:

    [Getter(Manufacturer)]

    _manufacturer = "Siemens"

    [Property(Temperature, Temperature > 0)]

    _temperature as int

 

    def Boil():

        pass # 如果不想有具体实现，可以使用关键字pass



# start main section that is executed when script is run

heater = Heater()

heater.Temperature = 96



# optional assembly attribute declarations used when compiling

[assembly: AssemblyTitle('Title')]

[assembly: AssemblyDescription('Description')]

一、Classes

正如上面例子看到在Boo中很容易进行类的定义与实现。在Boo的类定义中，可以很容易使用Property、Getter、Setter这三个attributes进行字段的属性设置。
其中Property还提供了第二个参数，可以用它指定Pre-condition，只有符合这个条件时才可以进行setter的操作：

[Property(Temperature, value > 0)]
_temperature as int

此外之外，我们也可以使用自定义的attribute来进行扩展(通过AbstractAstAttribute)。

类的默认修饰符是public，类中所有的字段默认都是 protected，所有的方法、属性和事件默认都是 public。

Boo 提供了一个非常有用的特性，它让你可以在实例化对象时直接指定属性的值。
heater = Heater(Temperature: 95, Manufacturer: 'Philips')

在Boo中继承同样很简单：

abstract class Device:

    abstract def Do():

        pass



class Alarm(Device):

    override def Do():

        print "Alarm!"

二、AbstractAstAttribute

其命名的惯例是："属性名称"+Attribute。
下面是一个简单的自定义属性(AbstractAstAttribute)例子，它继承自Boo的PropertyAttribute（继承于AbstractAstAttribute）：

import Boo.Lang.Compiler

import Boo.Lang.Compiler.Ast

 

class NonEmptyStringAttribute (PropertyAttribute):

    static preCondition = [| value is not null and len(value) > 0 |]

 

    def constructor(propName as ReferenceExpression):

        super(propName,preCondition.CloneNode())



class Person:

    [NonEmptyString(Name)]  # line 4

    _name as string

 

    [property(Age)]

    _age as int

 

    override def ToString():

        return _name

 

p = Person(Name:"john",Age:36)

p.Name = ''   # line 14

print p

相比复杂的函数调用，AST literals则提供了一个更简洁、更友好的方式用以构建Boo Ast nodes。

// using constructor calls.

mie = MethodInvocationExpression(ReferenceExpression('print'), 

   StringLiteralExpression('Hello,world'))



// ast literals allow you to say:

mie = [| print "Hello,world" |]

也就是说，你可以直接从Boo代码中构建Ast对象。

【注】：这里[| print "Hello,world" |]被称为Quasi-Quotation。

下面是详细的英文解释：A quasi-quotation evaluates its body as a code tree expression.
This is a special type of operator that tells Boo that whatever is inside of the block is to be parsed and returned as an AST(abstract syntax tree) node.

$ is generally called the "splice" operator and it means "evalute me at compilation time".
The splice application $(condition.ToCodeString()) automatically lifts the string value returned by ToCodeString to a proper StringLiteralExpression. 

下面是前一篇文章中使用AbstractAstAttribute的例子：

import System

import Boo.Lang.Compiler

import Boo.Lang.Compiler.Ast



# AST Attributes inherit from AbstractAstAttribute

class EnsureAttribute(AbstractAstAttribute): 

 # The expression that we were supplied

 # note that this happens during compilation

 expr as Expression

 # Store the expression in a field

 def constructor(expr as Expression):

  self.expr = expr  



 # Now we get the chance to make the changes that we want 

 def Apply(target as Node):

  # we cast the target to a ClassDefinition and 

  # start iterating over all its members

  type as ClassDefinition = target

  for member in type.Members:

   method = member as Method

   continue if method is null

   # if the member is a method, we modify

   # it to include a try/ensure block, in which 

   # we assert that the expression that we got must

   # be true. Then we override the method body with 

   # this new implementation.

   block = method.Body

   method.Body = [|

    block:

     try:

      $block

     ensure:

      assert $expr

   |].Body



# 使用方法如下: 

[Ensure(name is not null)]

class Customer:



 name as string



 def constructor(name as string):

  self.name = name



 def SetName(newName as string):

  name = newName

【注】：
Boo AstAttributes explained有详细的描述，对大家的理解会有很大帮助。

三、AbstractAstMacro

Boo中的Macros是在编译过程阶段被编译器扩展，并根据相应的参数和代码转换为AST以实现Boo编译器扩展的能力，因此通常用Macros来创建你自己的关键字。

在 Boo 里的某些述句，像 print 和 using，其实都是通过Macro来实现的。Macro 可以接受参数Arguments，也可以拥有代码块Block。其语法如下：
SomeMacro arg1, arg2, ...:
  block

值得注意的是，收到的参数并不能直接Evaluate使用，它们会被编译为 AST (Abstract Syntax Tree)表达式以进行操作，也就是说，参数并没有真正被赋值(evaluate)。
Macro 通常用来产生代码，它们会在编译时期以真正的代码取代。

如同自定义属性(AbstractAstAttribute)一样，Macro的名称必须以 'Macro' 结尾。
要使用自定义Macro，你遇到最大的问题在于必须对 AST有相当程度的了解，要建立运算式和述句，你需要了解编译器如何表现它们。
由于Macro正是Boo的优势所在，随后我会再写一篇文章希望可以详细介绍它。

在上篇文章最后部分我给出了大师的代码，其中unroll和unroll2就是分别用不同的方法实现Macro（其实本质是一样的）：

// Method 1

import System

import Boo.Lang

import Boo.Lang.Compiler

import Boo.Lang.Compiler.Ast



# We create a class for the macro, the class name is

# meaningful, [macro name]Macro allows us to later refer

# to the macro using just [macro name].

# Note that we inherit from AbstractAstMacro

class UnrollMacro(AbstractAstMacro):

 # Here we perform the actual compiler manipulation

 # the compiler hands us a macro statement, and we have

 # to return a statement back, which will replace it.

 def Expand(macro as MacroStatement) as Statement:

 

  # define a block of code

  block = Block()

  

  # extract the second parameter value

  end = cast(IntegerLiteralExpression, macro.Arguments[1]).Value

  

  for i in range(end):

   # create assignment statement, using the block: trick and add it to 

   # the output

   statements = [|

    block:

     $(macro.Arguments[0]) = $i

   |].Body

   block.Add(statements)

   

   # add the original contents of the macro

   # to the output

   block.Add(macro.Body)

   

  return block



// Method 2

import System

import Boo.Lang

import Boo.Lang.Compiler

import Boo.Lang.Compiler.Ast



# Using the MacroMacro, we don't need a class,

# just to define what we want the macro to do

macro Unroll2:

 # define a block of code

 block = Block()

 

 # extract the second parameter value

 end = cast(IntegerLiteralExpression, Unroll2.Arguments[1]).Value

 

 for i in range(end):

  # create assignment statement, using the block: trick and add it to 

  # the output

  statements = [|

   block:

    $(Unroll2.Arguments[0]) = $i

  |].Body

  block.Add(statements)

  

  # add the original contents of the macro

  # to the output

  block.Add(Unroll2.Body)

  

 return block



# 使用方法如下: 

unroll i, 5:

 print i

 

unroll2 i, 5:

 print i

最后大家看看下面这个简单的Macro，看看它是做什么用的：

import System

import Boo.Lang.Compiler

import Boo.Lang.Compiler.Ast



class AssignFieldsMacro(AbstractAstMacro): 

    override def Expand(macro as MacroStatement):  

        ctor = macro.GetAncestor(NodeType.Constructor) as Constructor

        b = Block()

  

        for param in ctor.Parameters: 

            assign = BinaryExpression(BinaryOperatorType.Assign,

                ReferenceExpression("_" + param.Name),

                ReferenceExpression(param.Name))

            b.Add(ExpressionStatement(assign))

  

        return b

【注】：
Boo AstMacros explained里有详细描述。

四、Meta Method

如果你不需要操作AST nodes，那么可以使用meta method代替Macros。

import System

import Boo.Lang.Compiler.Ast



class MetaMethods:

    [meta]

    static def verify(expr as Expression) as UnlessStatement:

        return [|

            unless $expr:

                raise $(expr.ToCodeString())

           |]

当编译这段Boo代码发现了verify关键字时，这个方法会通知编译器用下面
[|
unless $expr:
  raise $(expr.ToCodeString())
|]
生成的实际代码来替换。

五、Extension Method

可以用来往已有的类型中添加新的方法，类似于C#中的Extension Method。请看前面的例子：

class MyExtensions:

# Creating an extension methods so 200.ms will be valid

[Extension] 

static ms[i as int]:

    get:

        return TimeSpan.FromMilliseconds(i)



# 使用方法:

limitedTo 200.ms:

    ......

六、IQuackFu

有时候如果能让类自己负责方法、属性的调用，将会非常有用。任何实现了 IQuackFu 接口的类都必须做到：
1.如何调用方法、2.如何设定属性、3.如何读取属性。
在Steve Donovan写的例子中，通过IQuackFu接口实现了类似JavaScript中对象的存取方式：

class Map(IQuackFu):

    _vars = {}  

    def QuackSet(name as string, parameters as (object), value as object) as object:

        _vars[name] = value 

    def QuackGet(name as string, parameters as (object)) as object:

        return _vars[name] 

    def QuackInvoke(name as string, args as (object)) as object:

        pass

 

e = Map()

e.Alice = 32

e.Fred = 22

e.John = 42

print e.Alice,e.Fred,e.John

还有前文中的XmlObject，它是实现了IQuackFu接口的类，因此可以根据节点名称找到相应的值：

class XmlObject(IQuackFu): # Implementing IQuakcFu interface

 

 _element as XmlElement   # The element field

 

 # Get the xml element in the constructor and store it a field

 def constructor(element as XmlElement):

  _element = element   

 

 # We do not support invoking methods, so we just ignore this

 # method. We could also raise NotSupportedException here.

 def QuackInvoke(name as string, args as (object)) as object:

  pass # ignored

 

 # If we wanted two way communication, we could have built

 # it into this method, but we aren't, so we are ignoring this 

 # method as well

 def QuackSet(name as string, parameters as (object), value) as object:

  pass # ignored  

 

 # Here we intercept any property call made to the object.

 # This allows us to translate a property call to navigating

 # the XML tree.

 def QuackGet(name as string, parameters as (object)) as object:

 # Get the node(s) by its name

  elements = _element.SelectNodes(name)

  if elements is not null: # Check that the node exists

  # Here we are being crafy, if there is only one node

  # selected, we will wrap it in a new XmlObject and 

  # return it, this allows us easy access throughout

  # the DOM.

   return XmlObject(elements[0]) if elements.Count == 1

  # If there is more than one, we are using a generator

  # in order to return an enumerator over all the nodes

  # that were matched, wrapping each of them in turn.

   return XmlObject(e) for e as XmlElement in elements 

  else:

   return null



 # This is to make it easier to work with the node 

 override def ToString():

  return _element.InnerText



# 它的调用方法如下：

print "Using XML OBject"

print " - - - - - - - - - "

xml = """

<People>

 <Person>

  <FirstName>John</FirstName>

 </Person>

 <Person>

  <FirstName>Jane</FirstName>

 </Person>

</People>

"""



xmlDocument = XmlDocument()

xmlDocument.LoadXml(xml)



doc = XmlObject(xmlDocument.DocumentElement)

for person as XmlObject in doc.Person:

 print person.FirstName

七、Generators

Boo支持下列三种Generators:
1. Generator Expressions
语法：<expression> for <declarations> [as <type>] in <iterator> [if|unless <condition>]

Generator Expression作为一个enumerator对象使用，所以可以作为函数返回值、函数参数以及赋值给一个变量：

// 作为函数返回值

def GetCompletedTasks():

    return t for t in _tasks if t.IsCompleted



// 作为变量值

i = 2

a = range(1,5)

generator = i*j for j in a

print(join(generator)) # prints "2 4 6 8"

2. Generator Methods
Generator方法可以让你有能力自己实现类似Generator Expression的效果，通过在方法中使用yield关键字来建立Generator方法。
例如：

# 你可以自定义实现irange函数（与系统提供的range相似）

def irange(begin as int, end as int, step as int):

    t = begin

    while t < end:

        yield t

        t += step



for t in irange(1,5,1):

    print t

def selectElements(element as XmlElement, tagName as string):

   for node as XmlNode in element.ChildNodes:

      if node isa XmlElement and tagName == node.Name:

         yield node

3. List Generators
提供快速创建List的方法，它有以下多种定义方式：
[element for item in enumerable]
[element for item in enumerable if condition]
[element for item in enumerable unless condition]

List(x**2 for x in range(5))

List(x+2 for x in range(5) if x % 2 == 0)

八、匿名函数/Closures

在Boo中有两种使用Closure的方式：
1、Block based syntax
heater.Notify += def(heater as Heater):
    print heater.Temperature

2、Braces based
heater.Notify +=  {heater as Heater| print heater.Temperature}

a = 0 # declare a new variable

getter = { return a }

setter = { value | a = value }



assert 0 == getter()

setter(42)

assert 42 == getter()

assert 42 == a

【注】：
1、在Boo有这样的语法特性：如果方法参数中某个参数是callable的函数，那么利用上述匿名函数的写法。
例如：
Boo内置函数map将IEnumerable中的每个元素进行指定函数的转换，然后再将结果放入一个新的IEnumerable对象回传回来。

def sqr(x as double):

    return x*x

iter = map(range(0,10),sqr)

print join(iter)



# 根据刚才的介绍我们也可以有如下更lambda方式的调用：

iter1 = map(range(0,10)) def(x as double):

    return x*x

iter2 = map(range(0,10),{x as double | x*x}) 

2、不定参数
在函数参数args前加*表示参数的数目将是不固定的，类似C#中的params。

// *args表示参数不固定，(object)是类似C#中object[]的表示方法

def Test(*args as (object)):

 return args.Length



print Test(1,2,3,4)

a = (2,3)

// 注意下面两种调用方式的不同

print Test(a)  // 1 

print Test(*a) // 2



// Currying 

// Boo

plusX = { a as int | return { b as int | return a + b }}  

print plusX(3)(4)

// C#

Func<int,Func<int, int>> plusX = delegate(int x) { return delegate(int y) {return x+y; }; };

Console.WriteLine(plusX(3)(4));

这些特性在我们用Boo来实现DSL中会十分的常见。

九、callable/ICallable

前面我们提到可以将函数赋值给变量，但是这个变量是什么类型呢？我们经常需要把函数当作一个参数传给另一个函数使用。
在Boo中，关键字callable就是将函数作为类型使用（函数指针），与C#中的delegate作用类似。
大家可以在前一篇文章“用Boo实现的Observer”中看到下面两者的含义是一样：

// Boo

callable NotifyEventHandler(heater as Heater)

// C#

public delegate void NotifyEventHandler(Heater heater);

ICallable interface
通常 Boo 允许你调用callable的类型，因此将自己的类实现ICallable接口，你也可以让你的类成为被调用的callable类型。

请看下面的例子：

class Fred(ICallable):

    def Call(args as (object)) as object: 

        return (args[0] as string) + (args[1] as string)

 

f = Fred()

assert f('one','two') == 'onetwo'

参考：

http://tore.vestues.no/category/boo/
http://zh.wikibooks.org/w/index.php?title=BOO/BooFunctions&variant=zh-cn

敬请期待：

循序渐进学Boo - 高级篇
循序渐进学Boo - DSL篇

【附上】 
前一阵看到老赵提到的“从CSDN的趣味题学Python”这篇文章，我也用Boo实现了一下（其实与Python极其类似，呵呵，照着改写就好了），权当做熟悉Boo语法。
第一题：

dic = {}

for s in "abcdab121":

    if s not in dic:

        dic[s] = 1

    else:

        dic[s] = cast(int,dic[s]) + 1

for n in dic.Keys:

    print "${n}:${dic[n]}"

第二题：

txt = "床前明月光，疑似地上霜，举头望明月，低头思故乡。"

offset = 6

b = reversed(i) for i in zip(*array(List(txt[i:i+offset]) for i in range(0,len(txt),offset)))

for i in b:

    print join(i,'|')

从这里大家可以看到Boo和Python在语法特性上十分相似。