有人能给我讲讲F#中的多半径(对象函数)编程的例子吗?

有两种方法可以将功能和面向对象的范例结合起来。在某种程度上,它们是独立的,您可以编写使用类型(以F#对象形式编写)构造的不可变(函数)代码。例如 Client 这样写的字应该是:

// Functional 'Client' class
type Client(name, income) =
  // Memebers are immutable
  member x.Name = name
  member x.Income = income

  // Returns a new instance 
  member x.WithIncome(ninc) =
    new Client(name, ninc)
  member x.Report() =
    printfn "%s %d" name income

WithIncome 方法(它“改变”客户机的收入)实际上不做任何修改-它遵循函数样式,创建一个新的、更新的客户机并作为结果返回它。

另一方面,在F#中,您也可以编写具有可变公共属性的面向对象代码,但在封面下使用一些不可变的数据结构。如果您有一些很好的函数代码,并且希望以传统(命令式/面向对象)的方式将其公开给C程序员,那么这可能很有用:

type ClientList() =
  // The list itself is immutable, but the private
  // field of the ClientList type can change
  let mutable clients = []
  // Imperative object-oriented method
  member x.Add(name, income) =
    clients <- (new Client(name, income))::clients
  // Purely functional - filtering of clients
  member x.Filter f = 
    clients |> List.filter f

(示例取自 Chapter 9 我的书。还有一些不可变的面向对象代码的例子,例如第14章中的并行模拟。

programming the small .

• MyGame
• Board -跟踪不再移动的工件,水平线完成。
• UI bool stateMenu
• Tetris -处理游戏状态。游戏结束和碎片碰撞。
• Piece -定义不同的俄罗斯方块形状及其运动和绘画。
• Player -处理用户输入。
• Shape -映射到灵长类动物的基本图形对象。
• Primative

我做了一个粗略的类图来帮助你。如果你有任何关于它的问题,请在评论部分随意提问。

here . 我使用的算法在它的核心(数组的重复变异步骤)是必需的,如果用函数式数据结构实现,将会受到影响。通过获取一个输入数组,对其进行只读复制,使其不被破坏,然后在执行算法的变异步骤后,在序列表达式中生成它的只读副本,我们在面向对象技术和函数技术之间取得了很好的平衡。链接的答案引用原始C++实现以及基准其他纯粹的功能实现答案。我的混合OO/功能实现的性能介于OO C++解决方案的优越性能和纯粹的功能性的F*解决方案之间。

这种在内部使用OO/mutable状态而在外部保持对调用者的纯状态的策略在整个F#库中使用,特别是在Seq模块中直接使用了IEnumerators。

here

总之,我认为在F#中使用mutable OO对于寻求性能提升的库设计人员来说是最强大的,同时保持库用户的所有功能都是纯功能的。

我不知道任何F#,但我可以给你展示一个在Scala中寻找的精确语言机制的例子。如果这没有帮助,就忽略它。

class Summation {

    def sum(aLow : Int, aHigh : Int) = {
        (aLow to aHigh).foldLeft(0) { (result, number) => result + number }
    }

}

object Sample {

    def main(args : Array[String]) {
        println(new Summation sum(1, 10))
    }

}

我试着把它简单化。注意,我们声明了一个类来求一个范围的和,但是实现是与函数样式一起使用的。这样,我们就可以抽象出我们用来实现一段代码的范例。

我不知道F#,但大多数用Scala编写的软件本质上是对象函数的。

Akka , Lift , SBT , Kestrel