Шаблон стратегии в F#

Вот более функциональный подход к вопросу:

type Strategy =
    | StrategyA
    | StrategyB

let step1 i = function
    | StrategyA -> "whatever"
    | StrategyB -> "something else"

let step2 s = function
    | StrategyA -> 0.0
    | StrategyB -> 4.5

let work strategy = 
    let i = 4
    let s = step1 i strategy
    let d = step2 s strategy
    d

Здесь следует использовать выражения объекта F#:

type IStrategy =
    abstract Step1: int -> string
    abstract Step2: string -> double

let strategyA =
    { new IStrategy with
        member x.Step1 _ = "whatever"
        member x.Step2 _ = 0.0 }

let strategyB =
    { new IStrategy with
        member x.Step1 _ = "something else"
        member x.Step2 _ = 4.5 }

Вы получаете лучшее из обоих миров: гибкость наследования и легкий синтаксис, как у функций.

Ваш подход с использованием записей функций хорош, но не самый идиоматический. Вот что предлагает Руководство по проектированию компонентов F# (стр. 9):

В F# существует несколько способов представления словаря операций, например использование кортежей функций или записей функций. В общем, мы рекомендуем вам использовать интерфейсные типы для этой цели.

ИЗМЕНИТЬ:

Обновления записей с использованием with — это здорово, но IntelliSense не очень хорошо работает, когда поля записи являются функциями. Используя интерфейсы, вы можете дополнительно настраивать, передавая параметры внутри выражений объекта, например.

let createStrategy label f =
    { new IStrategy with 
        member x.Step1 _ = label
        member x.Step2 s =  f s }

или прибегнуть к реализации интерфейса с использованием interface IStrategy with (это было бы так же, как подход C #), когда вам нужна большая расширяемость.

Вы упоминаете возможность простого использования лямбда-выражений в С#. Для стратегий с несколькими шагами это часто идиоматично. Это может быть очень удобно:

let f step1 step2 = 
    let i = 4
    // ...
    let s = step1 i
    // ...
    let d = step2 s
    //  ...
    d

Нет необходимости в определениях интерфейса или выражениях объектов; предполагаемых типов step1 и step2 достаточно. В языках без функций высшего порядка (в которых, как я полагаю, был изобретен паттерн стратегии) ​​у вас нет этой опции, и вместо этого вам нужны, например, интерфейсы.

Функцию f здесь, по-видимому, не волнует, связаны ли step1 и step2. Но если вызывающая сторона это делает, ничто не мешает ему объединить их в структуру данных. Например, используя ответ @pad,

let x = f strategyA.Step1 strategyA.Step2
// val it = 0.0 

В общем, «идиоматический способ» зависит от того, почему вы в первую очередь рассматриваете шаблон стратегии. Паттерн стратегии предназначен для сшивания функциональности; функции более высокого порядка также часто очень хороши для этого.

Объектные выражения поддерживают только один интерфейс за раз. Если вам нужно два, используйте определение типа.

type IStrategy =
    abstract Step1: int -> string
    abstract Step2: string -> double

type strategyA() =
    let mutable observers = []

    interface System.IObservable<string> with
        member observable.Subscribe(observer)  =
            observers <- observer :: observers
            { new System.IDisposable with
                 member this.Dispose() =
                    observers <- observers |> List.filter ((<>) observer)}

    interface IStrategy with
        member x.Step1 _ = 
            let result = "whatever"
            observers |> List.iter (fun observer -> observer.OnNext(result))
            result
        member x.Step2 _ = 0.0

type SomeKindaWorker() =
    member this.Work(strategy : #IStrategy) =
        let i = 4
        // some code ...
        let s = strategy.Step1(i)
        // some more code ...
        let d = strategy.Step2(s)
        // yet more code ...
        d

let strat = strategyA()
let subscription = printfn "Observed: %A" |> strat.Subscribe
SomeKindaWorker().Work(strat) |> printfn "Result: %A"
subscription.Dispose()

Еще один паттерн, который я часто вижу, — это возврат объектных выражений из функций.

let strategyB(setupData) =
    let b = 3.0 + setupData

    { new IStrategy with
        member x.Step1 _ = "something else"
        member x.Step2 _ = 4.5 + b }

Это позволяет вам инициализировать вашу стратегию.

SomeKindaWorker().Work(strategyB(2.0)) |> printfn "%A"