f#

关于类型中的静态字典的困惑的答案，在 F# 中完成了一个建议：and just in general: try to use fewer classes and more modules and functions; they're more idiomatic in F# and lead to fewer problems in general

这是一个很好的观点，但我 30 年的 OO 只是还不想放弃课程（尽管当我们离开 C 时，我疯狂地与 C++ 作斗争......）

所以让我们拿一个实际的现实世界对象：

type Currency =
    {
        Ticker: string
        Symbol: char
    }

and MarginBracket =
    {
        MinSize:           decimal
        MaxSize:           decimal
        Leverage:          int
        InitialMargin:     decimal
        MaintenanceMargin: decimal
    }

and Instrument =
    {
        Ticker:             string
        QuantityTickSize:   int
        PriceTickSize:      int
        BaseCurrency:       Currency
        QuoteCurrency:      Currency
        MinQuantity:        decimal
        MaxQuantity:        decimal
        MaxPriceMultiplier: decimal
        MinPriceMultiplier: decimal
        MarginBrackets:     MarginBracket array
    }

    // formatting
    static member private formatValueNoSign (precision: int) (value: decimal) =
        let zeros = String.replicate precision "0"
        String.Format($"{{0:#.%s{zeros}}}", value)

    static member private formatValueSign (precision: int) (value: decimal) =
        let zeros = String.replicate precision "0"
        String.Format($"{{0:+#.%s{zeros};-#.%s{zeros}; 0.%s{zeros}}}", value)


    member this.BaseSymbol  = this.BaseCurrency.Symbol
    member this.QuoteSymbol = this.QuoteCurrency.Symbol

    member this.QuantityToString    (quantity)          = $"{this.BaseSymbol}{Instrument.formatValueSign    this.QuantityTickSize quantity}"
    member this.PriceToString       (price)             = $"{this.QuoteSymbol}{Instrument.formatValueNoSign this.PriceTickSize price}"
    member this.SignedPriceToString (price)             = $"{this.QuoteSymbol}{Instrument.formatValueSign   this.PriceTickSize price}"
    member this.RoundQuantity       (quantity: decimal) = Math.Round (quantity, this.QuantityTickSize)
    member this.RoundPrice          (price : decimal)   = Math.Round (price, this.PriceTickSize)

    // price deviation allowed from instrument price
    member this.LowAllowedPriceDeviation (basePrice: decimal)  = this.MinPriceMultiplier * basePrice
    member this.HighAllowedPriceDeviation (basePrice: decimal) = this.MaxPriceMultiplier * basePrice


module Instrument =
    let private  allInstruments   = Dictionary<string, Instrument>()
    let list     ()               = allInstruments.Values
    let register (instrument)     = allInstruments.[instrument.Ticker] <- instrument
    let exists   (ticker: string) = allInstruments.ContainsKey (ticker.ToUpper())
    let find     (ticker: string) = allInstruments.[ticker.ToUpper()]

在这个例子中，有一个带有数据的Instrument对象和一些帮助成员，还有一个模块，当需要按名称查找对象时充当存储库（在本例中为交易代码，因此它们是已知的和格式化的，它不是一个随机字符串）

我可以将帮助成员移动到模块，例如：

member this.LowAllowedPriceDeviation (basePrice: decimal)  = this.MinPriceMultiplier * basePrice

可以变成：

let lowAllowedPriceDeviation basePrice instrument = instrument.MinPriceMultiplier * basePrice

所以对象会变得更简单，最终可以变成一个简单的存储类型，没有任何增强。

但我想知道实际好处是什么（让我们只考虑可读性、可维护性等）？

此外，我不知道如何将其重新构建为不是一个类，缺少模块中的“内部”类并通过它执行所有操作，但这只会改变它。

回答

let printAll toString = List.iter (printfn "%s" << toString)

printAll priceToString (list())

printAll (fun i -> i.PriceToString) (list())

printAll (fun (i: Instrument) -> i.PriceToString) (list())