码迷,mamicode.com
首页 > 其他好文 > 详细

奇技淫巧:F#泛型特化的最终优化

时间:2014-08-31 14:29:51      阅读:219      评论:0      收藏:0      [点我收藏+]

标签:style   color   使用   io   ar   代码   sp   工作   on   

       上回讲到,F#中 module 里的泛型变量实际上是泛型函数。由此,在一个泛型特化的实现中出了岔子。最后通过泛型得以解决。使用 F# 来做泛型特化,相比 C# 有这个优势:F# 中直接支持函数赋值,而无须使用委托。避免了 C# 例子里面,为了节省 Lumbda 与委托之间的转换,而做出的丑陋的反射、拆箱操作。代码不再这么艰涩,我们重新来看看这段代码:

        module Mithra =

        type Cache<‘T>() =

            static member val GetBytes: ‘T->byte[] = Unchecked.defaultof< ‘T -> byte[] > with get, set 

        Cache<int16>.GetBytes <- BitConverter.GetBytes

        Cache<int32>.GetBytes <- BitConverter.GetBytes

        Cache<int64>.GetBytes <- BitConverter.GetBytes

        Cache<String>.GetBytes <- Encoding.UTF8.GetBytes 

        let GetBytes<‘T> = Cache<‘T>.GetBytes

 
  还要重申这点:F# 中 module 里的泛型变量实际上是泛型函数。所以,最后这句 let GetBytes<‘T> = Cache<‘T>.GetBytes     仍然是函数调用。我们使用 let a = GetBytes<String>("123")      时,实际上调用的代码却是:

        let GetBytes = GetBytes<String>()

        let a = GetBytes("123")

       实际上等于多了一层薄薄的函数封装 。但是,即使是 0.01mm,也是隔靴搔痒。
       要在 F# 中想去掉这层封装,却需要点技巧。我们的目的是可以进行这样的调用:
   let a = Cache<String>.GetBytes("123")

     目前不可如此,因为直接调用的话,就不会执行后面的特化语句,就会调出一个 null 函数。C# 的例子是把 Cache<T> 放在另一个静态类型里,而把特化代码放在该静态类型的静态构造中,第一次进入静态类就会调用构造函数,就会执行此特化代码。F# 不可以,它的语法不允许把一个类衔套到另一个类里面。类可以放在 module 里面,但是 module 不完全等于 C# 静态类。调用 module 里面的类不会执行 module 里面的赋值代码。所以只能用互相递归的类来模拟:  

    type Cache<‘T>() =

        static member val GetBytes: ‘T->byte[] = Unchecked.defaultof< ‘T ->byte[] > with get, set

        // 必须为 val,才会执行后面的代码

        static member val private __ = cachEx.__

    andcachEx() =

        static do Cache<int16>.GetBytes <- BitConverter.GetBytes

        static do Cache<int32>.GetBytes <- BitConverter.GetBytes

        static do Cache<int64>.GetBytes <- BitConverter.GetBytes

        static do Cache<String>.GetBytes <- Encoding.UTF8.GetBytes

        static do Cache<slice>.GetBytes <- fun (src, idx, len)-> src.[idx..idx + len - 1]

        // 这里须为属性或者函数,才会执行 static do

        static member internal __ = ()

       当调用 Cache<String>.GetBytes 函数的时候,最先执行的是 Cache<String的静态函数,F# 中没有明确的静态函数,微软的文档里叫做静态绑定,就是执行所有的 static let 和 static do 语句,另外,文档里没有明确提及的,计算 static member val 的值。所以,现在是先计算 Cache<String>.GetBytes 函数的默认值,然后再计算 Cache<String>.__ 的值。后一项计算则调用了递归类的 cachEx().__  属性。 而调用这个属性之前必须先自动调用 cachEx() 的静态函数,就是特化工作,我们的目的达到了。cachEx() 的静态构造只会执行一次,也就意味着特化工作也不会重复执行。最后,为了使用方便,我们还可以:

    letinline GetBytes<‘T> = Cache<‘T>.GetBytes 

F# 中的 
inline 是 100% 内联,不像C++。C++ 是不确定的。有时,不确定的内联带来的不仅仅是性能的不确定,还有可能是行为上的不确定。正如一开始的那段代码。GetBytes 不内联的话,运行是正确的,但是内联了之后,就会出错。如果加了 inline 之后,编译器有时候选择内联,有时候不选择内联,估计编程者要郁闷死了。所幸的是,普通的C++没有泛型,只有C++/Cli有。

 

奇技淫巧:F#泛型特化的最终优化

标签:style   color   使用   io   ar   代码   sp   工作   on   

原文地址:http://www.cnblogs.com/greatim/p/3947632.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!