【51CTO獨家特稿】最近，人們對于領域特定語言F#中DSL原型設計的興趣卷土重來。這些語言不僅能夠為特定領域提供更好等級的提煉，從而有助于減少在通用語言中因低等級構造而造成的錯誤；而且通過提供額外配置、定制的業務邏輯等，它們為用戶提供了一種有效的機制，用于細調你的應用程序。總之，DSL能夠讓你的應用程序更加多樣化并具有更好的伸縮性。51CTO向您推薦Visual Studio 2010中F#的一些資源

大致來講，領域特定語言的工作方式有兩種——你可以通過對以源DSL編寫的源文本進行轉譯來實施，或者通過將源文本編譯為可執行代碼。這兩種方式都有著獨特的優點和缺點。對于解釋器和編譯器的實施階段，很多都是類似的，甚至一模一樣；例如，語法和語義檢查在兩種方式中是共同的。在獲得合適的內部重現（inner representation）之后，編譯器實施包括幾個階段，逐步將這種重現分解為低等級的指令，生成匯編語言原生碼，或管理代碼（取決于目標平臺）。解釋器與之相反，很少執行這些階段。作為替代，你可以實施所謂的DSL 的“操作語義”（operational semantic）；例如，為內部重現編寫一個評估器。

圖1. 運行中的Simply

你可以在Simply上進行構建，來創建新的DSL并將其嵌入到你自己定制的開發外科中。此處演示的應用程序 SimplyLogo從零開始構建，F# 代碼少于500 行。

在本文介紹的F#中DSL原型設計，我們將為一個小型的DSL（由于其類似 C 語言的語法和簡潔，我將其稱為“Simply”）編寫一個解釋器，然后使用與Logo 那種語言類似的內置函數將其實例化。你可以通過在表達式語法器上來構建以完成實例化。之前我們已經在相關文章中進行講述，在這篇文章中，你可以看到活躍模式（active pattern）提供了一個***的機制（雖然付出了一點速度的小代價），能夠用于構建符合類型安全規則的語法器，它與用戶語法中的正規的 BNF 句法非常相似；并且能夠在增強的AST 重現上實施語言檢查（本文）和評估器（下一篇文章）。使用這種語言，你可以快速生成圖像，這些圖像能夠使用簡單的畫圖命令來定義——并且你可以在所有你需要的語境中使用這個核心評估器。在圖 1 中所示為該 DSL 的一種可能的嵌入。在本文中，我們主要關心的是構建 Simply 的語法器和檢查源程序以確認語法的正確性。

51CTO譯者注：為了學習這個系列的文章，你需要下載 F# May 2009 CTP 或Visual Studio 2010 Beta 1。

Simply 概述

Simply 是本文的DSL，它是一個具有靜態作用域、嵌套變量（nested variable）和函數聲明，以及簡單循環構造的小型編程語言。下面是一個很短的 Simply 程序：

var x = 2   
fun x(a b) { a + b + x }   
fun x(y) { y + x(1 2) }   
repeat 100 as i { x(i) } 

這段程序很容易讀懂，它包含四條命令，定義了一個變量、兩個函數和一個循環。為了分析這些命令的語法，你需要對上文中講述的語法器進行擴展。

對具有循環構造、變量和函數的Simply進行擴展

前文中實施的語法器使用函數調用對算術表達式進行語法分析并將其翻譯為定制的 AST 類型。對于 Simply，你需要一個稍微更為高級的內部重現來對表達式進行語法分析，這些表達式包含了簡單變量以及與其密切關聯的少量語言擴展，用于定義變量和函數，以及用簡單的循環構造（循環區塊）來表達循環。

如果你已經將AST 定義放在其自身模塊中，下面你可以看到新的擴展版本：

namespace IntelliFactory.Simply   
module Ast =  
    type var = string   
    type Expr =  
 
 | Number of float   
 | BinOp of (float -> float -> float) * Expr * Expr  
 | Var of var  
 | FunApply of var * Expr list  
 
 static member Sum (e1, e2) = BinOp (( + ), e1, e2)  
 static member Diff (e1, e2) = BinOp (( - ), e1, e2)  
 static member Prod (e1, e2) = BinOp (( * ), e1, e2)  
 static member Ratio (e1, e2) = BinOp (( / ), e1, e2) 

你可能已經注意到，我對這個模塊的代碼格式進行了細小的調整，以便符合 F# 編碼語法指南。我們的理想是用最少的代碼實現最多的功能，同時在需要增加代碼以及所表達的功能時仍然能夠進行快速建模（prototyping）并且修改最小化?，F在，你可以在代碼中添加 AST 增強，其指向不再是那些普通的算術表達式：

   type Command =  
| VarDef of var * Expr  
| FunDef of var * var list * Command  
| Repeat of Expr * var * Command  
| Sequence of Command list  
| Yield of Expr type Prog = Program of Command list 

這些F#中DSL原型設計的代碼定義了：

一個 Command 類型，可以對變量定義繼續編碼（利用一個值進行初始化） 函數定義（具有函數名稱、常規的參數列表和一個體現函數主體的 Command 值） 循環區塊（具有控制變量、循環程度表達式和一個用于體現循環區塊主體的 Command 變量） Command 排序（對于定義需多個簡單表達式的函數主體或循環區塊非常有用） 簡單表達式執行。一列這樣的表達構成了一個程序。利用這些類型，你現在可以擴展你支持創建的表達式語法器。為了更加方便，你可以再次使用 Listing 1 中代碼，然后對其進行稍微的增強：

這個核心語法器中唯一的更改（格式更改除外）位于（|Factor|_|）活躍模式在：這個版本添加了簡單的變量變量引用（第三條規則），以滿足增強的 AST 表達式語言中的相應的附加規則。

到這里，你就可以真正地開始加速，快速寫下 DSl 語法器的其余部分。首先添加關鍵字和特定字符的規則：

let (|LBRACE|_|) s = "{" |> MatchSymbol s  
let (|RBRACE|_|) s = "}" |> MatchSymbol s  
let (|EQ|_|) s = "=" |> MatchSymbol s  
let (|VAR|_|) s = "var" |> MatchSymbol s  
let (|FUN|_|) s = "fun" |> MatchSymbol s  
let (|REPEAT|_|) s = "repeat" |> MatchSymbol s  
let (|AS|_|) s = "as" |> MatchSymbol s 

語法分析命令的規則是語法規則轉換為之前地定義的活躍模式的一種簡單的翻譯。

let rec (|Command|_|) = function 
| VAR (ID (v, EQ (Expression (expr, rest)))) 
-> (Ast.Command.VarDef (v, expr), rest) 
|> Some | FUN (ID (f, LPAREN (Star (|ID|_|) [] ( pars, RPAREN (Command (body, rest)))))) 
-> (Ast.Command.FunDef (f, pars, body), rest)
 |> Some | REPEAT (Expression (i, AS (ID (v, Command (body, rest))))) 
-> (Ast.Command.Repeat (i, v, body), rest) 
|> Some | LBRACE (Star (|Command|_|) [] (commands, RBRACE rest)) 
-> (Ast.Command.Sequence commands, rest)
 |> Some | Expression (e, rest) 
-> (Ast.Command.Yield e, rest) |> Some | _ -> None 

例如，讓我們看看上面（|Command|_|）活躍模式中的***條規則。它字母的意思是：

“批評‘var’關鍵字，然后是標識符并將其與‘v’捆綁，然后是等于符號，然后是一個綁定到‘expr’的表達式；然后返回帶有變量及其初始值的 Command.VarDef 值，還有其余的輸入字符串，作為一個成功的匹配?！?/P>

其他規則一樣易于理解和構造。有一個細節需要進一步解釋，在函數定義或排序規則中如何使用（|Star|_|）活躍模式。記住，這是一個參數化（parameterized）的活躍模式，在它被應用到你再次匹配的值之前，它具有了兩個變量。***個變量是一個活躍模式，你可以“運行”零次或多次（名稱 Star，它反映了常規語言如 BNF 或常規表達式中的 star 操作符），第二變量是初始累加器，用于收集請求結果。由于該累加器的初始值通常是一個空列表，因此你可能會選擇以一種不需要初始值的方式重寫這個活躍模式；因此這就給了你一直更為緊湊的方式來指定“零次或多次”這種類型的規則。

***，你可以編寫定義了這個程序語法的規則：

let (|Prog|_|) = function   
| Star (|Command|_|) [] (commands, rest) -> (Ast.Prog.Program commands, rest)   
|> Some | _ ->             None 

或者，編寫一個格式稍微有點冗長的規則：

   let (|Prog|_|) s = match s with   
| Star (|Command|_|) [] (commands, rest) -> (Ast.Prog.Program commands, rest)   
|> Some | _ ->             None 

你可以在 Simply 程序上快速檢驗你的語法器——只需通過選取代碼并按 Alt+Enter 鍵將 AST 和語言模塊載入到 F# Interactive 中，然后測試一個 Simply 小程序：

open Language " var x=1 var x=2 var x=3 fun foo(y)   
{ fun bar(foo) { var xx=x+1 foo+x } bar(y*2)   
}   
repeat 1000 as x { foo(x) }" |> (|Prog|_|) |> printf "Result=%A\n";;  
 > Result=Some (Program [VarDef ("x",Number 1.0);   
VarDef ("x",Number 2.0); VarDef ("x",Number 3.0);  
FunDef ("foo",["y"], Sequence [FunDef ("bar",["foo"], Sequence [VarDef ("x",BinOp (,Var "x",Number 1.0));   
Yield (BinOp (,Var "foo",Var "x"))]);   
Yield (FunApply ("bar",[BinOp (,Var "y",Number 2.0)]))]);   
Repeat (Number 1000.0,"x",Sequence [Yield (FunApply ("foo",[Var "x"]))])], "") >