五十种语言的“圣诞快乐”（下）：F#实现

测试积点老人

不知道大家的圣诞节过的如何？有没有玩点啥有趣的东西？上次的文章中我们主要分析了使用Google Translate进行文字翻译的方式，并使用C#写了一个简单的的翻译程序，效果良好。不过，在平时开发过程中，对于此类问题我常用F#来解决这样的问题。那么使用F#来实现此类任务有什么优势吗？不错，我们现在便来看看这个问题。
简单的F#实现
话说F#和.NET框架可以无缝集成，因此理论上之前我们的C#代码怎么写，便可以使用F#来照着抄一遍。例如，我们先定义一个Sync模块，其中先定义一个获取全部目标语言的getLanguages函数：

1. #light
   
2. 
   
3. module Sync
   
4. 
   
5. open System
   
6. open System.Text.RegularExpressions
   
7. open System.Net
   
8. open System.Web
   
9. open System.Web.Script.Serialization
   
10. open System.Collections.Generic
    
11. open System.Text
    
12. 
    
13. type private LangMap = Dictionary<string, string>
    
14. 
    
15. let private getLanguages() =
    
16. let url =
    
17. "http://translate.googleapis.com" +
    
18. "/translate_a/l?client=te&hl=zh-CN&cb=_callbacks_._0g3mb650r"
    
19. 
    
20. let webClient = new WebClient()
    
21. let script = webClient.DownloadString(url)
    
22. 
    
23. let json = Regex.Match(script, @"'tl':({.+})}\)").Groups.Item(1).Value
    
24. let serializer = new JavaScriptSerializer()
    
25. serializer.Deserialize<LangMap>(json)

复制代码

这个函数与之前C#版本的GetLanguages方法可谓一模一样，其返回结果便是一个字典，存储了目标语言的代号和名称——当然，这边我为Dictionary<string, string>取了一个别名LangMap，这样使用起来感觉更为方便，语义也更加清晰。
同样的，我们“翻译”一遍之前的Translate方法，变成如今的translateText函数：

1. let private translateText (text:string) sl tl =
   
2. let url =
   
3. "https://translate.googleapis.com" +
   
4. "/translate_a/t?client=te&format=html&v=1.0"
   
5. 
   
6. let encoded = text |> HttpUtility.UrlEncode
   
7. let data = sprintf "q=%s&sl=%s&tl=%s&tc=1" encoded sl tl
   
8. 
   
9. let webClient = new WebClient()
   
10. webClient.Encoding <- Encoding.UTF8
    
11. let userAgent = "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0;)"
    
12. webClient.Headers.Add(HttpRequestHeader.UserAgent, userAgent)
    
13. 
    
14. let json = webClient.UploadString(url, data)
    
15. let serializer = new JavaScriptSerializer()
    
16. serializer.Deserialize<string>(json)

复制代码

而最终进行多种语言翻译的，则是使用公有的translate函数：

1. let translate text sl =
   
2. let languages = getLanguages()
   
3. 
   
4. let translated =
   
5. languages
   
6. |> Seq.map (fun p -> translateText text sl p.Key)
   
7. 
   
8. let names = languages  |> Seq.map (fun p -> p.Value)
   
9. Seq.zip names translated |> Seq.toArray

复制代码

首先，所有语言会存入一个叫做languages的容器中，它是一个字典，实现了IEnumerable<KeyValuePair<string, string>>，在F#中便是seq<KeyValuePair<string, string>>，因此我们使用Seq模块的map方法将其转化为翻译后的结果，并存放在translated中。然后，我们获得每种语言的名称，最终与翻译的结果zip即可。translate函数最终返回的是一个存放着元组的数组，元组的类型是string * string。
至于调用，自然是很容易的。F#控制台程序也需要定义main函数，如下：

1. [<EntryPoint>]
   
2. let main args =
   
3. 
   
4. let output =
   
5. Sync.translate "圣诞快乐" "zh-CN"
   
6. |> Array.map (fun (lang, text) -> sprintf "%s：o%s" lang text)
   
7. 
   
8. File.WriteAllLines("output.txt", output)
   
9. 
   
10. Console.ReadLine() |> ignore
    
11. 0

复制代码

当然，如果我们只是把F#用成这样，那实在就没有多大价值了。
异步编程
刚才的代码放在名为Sync的模块中，很明显这是“同步”的。对于此类IO操作，使用同步IO是一件非常不明智的事情。当然，对于目前这样的小程序来说，使用同步IO并没有什么问题。但是您一会儿也会发现，异步IO对目前的情形也是十分有价值的。
异步IO除了“不阻塞”的含义在里面之外，我认为还需要包括“事件触发”这个含义在里面。例如，JDK很早就支持了异步IO，但是直到目前为止（JDK 6），它在Windows平台上的相关实现，依旧只是简单的“非阻塞”，而非基于Windows的异步IO机制IOCP。于此相对，它在Linux平台上的实现却使用了高效的epoll。因此，如Mina，Jetty等高性能IO通信框架在Windows下的表现要比Linux差很多——您会经常看到时不时有人以此来证明Windows性能低下，但我倒认为这只能证明Java的跨平台只是“功能”而不是“性能”，意义大打折扣。
至于跨平台的IO类库并非没有，例如著名的libevent便是一例。不过在JDK 7中“据说”会修复这方面问题，拭目以待。
对于在Windows平台下真正的异步IO机制IOCP，我之前在多篇文章中有所提及（包括与其有关的IO线程池）。在.NET平台上，各种类库的异步通信方式自然使用了IOCP，自不必提。但是，异步编程的性能虽然好，但它的最大问题还是“方便性”，最基础的一点，由于任务流需要分两部分进行，那么我们自然需要保留上下文吧？即便是如C#中提供了匿名函数，可以自动生成闭包来保持上下文，但是还是有其他问题——例如，异常处理怎么办？
当然，利用C#中的yield关键字可以简化这些问题，但是F#给我们更好的解决方案。F#应对异步编程提供了一个名为“异步工作流”的结构，它基于F#的“工作流”特性开发了一套异步类库，关于这一点在上次的Comet原型中也有提及。异步工作流的优势在于把一个“二段式”的异步调用合并在一起，这样在调用的时候便可以同步操作的方式进行。如此，无论是逻辑中的上下文信息还是异常处理都变得异常简单。
对于异步操作的“合并”，例如可以根据最常见的APM模式（即Begin/End）生成“单步”的工作流。不过对于WebClient来说，它的异步操作并非APM形式，而是基于“事件”。不过F#对此也提供了支持，因此我们可以为WebClient扩展两个函数：

1. type WebClient with
   
2. member c.GetStringAsync(url) =
   
3. async {
   
4. c.DownloadStringAsync(new Uri(url))
   
5. let! args = c.DownloadStringCompleted |> Async.AwaitEvent
   
6. return args.Result
   
7. }
   
8. 
   
9. member c.PostStringAsync(url, data) =
   
10. async {
    
11. c.UploadStringAsync(new Uri(url), data)
    
12. let! args = c.UploadStringCompleted |> Async.AwaitEvent
    
13. return args.Result
    
14. }

复制代码

我们在F#中可以“打开”任意一个类型，为其添加新的成员——不过自然这只是如C#中扩展方法那样的语法糖而已。我们为WebClient添加了GetStringAsync与PostStringAsync两个方法，它们返回的都是结果为一个字符串的异步数据流（即Async<string>），执行这个异步数据流之后便可以得到最终的结果。值得注意的是，async块只是在构造一个逻辑块，并没有真正调用。
于是，我们的getLanguages函数也可进行改写：

1. let private getLanguages() =
   
2. async {
   
3. let url =
   
4. "http://translate.googleapis.com" +
   
5. "/translate_a/l?client=te&hl=zh-CN&cb=_callbacks_._0g3mb650r"
   
6. 
   
7. let webClient = new WebClient()
   
8. // let script = webClient.DownloadString(url)
   
9. let! script = webClient.GetStringAsync(url)
   
10. 
    
11. let json = Regex.Match(script, @"'tl':({.+})}\)").Groups.Item(1).Value
    
12. let serializer = new JavaScriptSerializer()
    
13. // serializer.Deserialize<LangMap>(json)
    
14. return serializer.Deserialize<LangMap>(json)
    
15. }

复制代码

您是否发现这段代码与之前的变化？没错，两者几乎一模一样。除了它变成了async构造块之外，唯一的区别只是被注释的两行代码。第一行代码中，原本我们使用的是同步的DownloadString函数，而现在我们则通过执行一个异步数据流（使用let!）来得到结果script——当然，执行的形式却是同步的。除此之外，最后返回结果需要使用return来标明。let!和return（以及其他的如return!）等操作符，都是F#编译器对“工作流”构造块（如async）使用中的“强制措施”，以此避免开发人员的误操作。
同样，translateText函数也将构造一个异步工作流：

1. let private translateText (text:string) sl tl =
   
2. async {
   
3. let url =
   
4. "https://translate.googleapis.com" +
   
5. "/translate_a/t?client=te&format=html&v=1.0"
   
6. 
   
7. let encoded = text |> HttpUtility.UrlEncode
   
8. let data = sprintf "q=%s&sl=%s&tl=%s&tc=1" encoded sl tl
   
9. 
   
10. let webClient = new WebClient()
    
11. webClient.Encoding <- Encoding.UTF8
    
12. let userAgent = "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0;)"
    
13. webClient.Headers.Add(HttpRequestHeader.UserAgent, userAgent)
    
14. 
    
15. let! json = webClient.PostStringAsync(url, data) // changed
    
16. let serializer = new JavaScriptSerializer()
    
17. return serializer.Deserialize<string>(json) // changed
    
18. }

复制代码

使用异步工作流的另一个好处在于，我们可以轻易地将异步工作流并行地执行。例如在目前的场景中，我们可以同时发起50多个异步IO请求，但同时却不占用任何线程——它们可能都在等着IO设备（即网卡）发送设备信号呢。于是乎，我们的translate函数便可以这样写：

1. let translate text sl =
   
2. async {
   
3. let! languages = getLanguages()
   
4. let! translated =
   
5. languages
   
6. |> Seq.map (fun p -> translateText text sl p.Key)
   
7. |> Async.Parallel
   
8. 
   
9. let names = languages |> Seq.map (fun p -> p.Value)
   
10. return Seq.zip names translated |> Seq.toArray
    
11. }

复制代码

并这样调用：

1. let output =
   
2. Parallel.translate "圣诞快乐" "zh-CN"
   
3. |> Async.RunSynchronously
   
4. |> Array.map (fun (lang, text) -> sprintf "%s：%s" lang text)

复制代码

这句代码中的Parallel便是指我们刚才开发的模块。这段代码的执行速度会比Sync模块要快很多，因此此时50多个翻译的请求并不是依次发出，而是同时发出，并通过响应IO设备的事件来工作。不阻塞，高效。
异步工作流的同步执行
之前的代码中，我们是将languages集合转化为一组translateText所生成的异步任务，然后由Async.Parallel合并成一个并行的异步任务。这种调用方式很简单，反而是如果您要将这组异步任务按照顺序一一执行起来比较麻烦。当然，这只是麻烦，并不困难，而且其实同样是非常自然的：

1. let translateSeq text sl =
   
2. let rec translateSeq' targets acc =
   
3. async {
   
4. match targets with
   
5. | [] -> return acc |> List.rev
   
6. | t :: ts ->
   
7. let! result = translateText text sl t
   
8. return! translateSeq' ts (t :: acc)
   
9. }
   
10. 
    
11. async {
    
12. let! languages = getLanguages()
    
13. let targets = languages |> Seq.map (fun p -> p.Key) |> Seq.toList
    
14. 
    
15. let! translated = translateSeq' targets List.empty
    
16. let names = languages |> Seq.map (fun p -> p.Value)
    
17. return Seq.zip names translated |> Seq.toArray
    
18. }

复制代码

您能解释一下这段代码的写法吗？
最后还是来看看执行效果吧。圣诞已过，新年将至。那么在这里就来祝各位兄弟们新年快乐吧！