В прошлом посте мы говорили, что об операторе let можно думать, как о приятном синтаксисе для продолжений с какой-то дополнительной закулисной работой.

Теперь мы готовы к тому, чтобы разобраться с методом Bind класса-строителя, который формализует этот подход. Bind — это сердце любого вычислительного выражения.

Обратите внимание, что "класс-построитель" в контексте вычислительных выражений — это не то же самое, что "паттерн строитель", который применяется для конструирования и валидации объектов.

Введение в "Bind"

Страница MSDN о вычислительных выражениях описывает let! как синтаксический сахар для метода Bind. Сравним их ещё раз:

Документация по оператору let! вместе с примером использования:

// документация
{| let! pattern = expr in cexpr |}

// пример
let! x = 43 in some expression

Документация по методу Bind, также с примером использования:

// документация
builder.Bind(expr, (fun pattern -> {| cexpr |}))

// пример
builder.Bind(43, (fun x -> some expression))

Обратим внимание на несколько важных моментов:

Bind принимает два параметра: выражение (43) и лямбду.
Параметр лямбды (x) связывается с выражением, переданным в качестве первого параметра. (По крайней мере, в этом примере. Подробности позже.)
Параметры Bind записываются в порядке, обратном к порядку в let!.

Иными словами, если мы запишем подряд несколько операторов let! вот так:

let! x = 1
let! y = 2
let! z = x + y

компилятор превратит их в вызовы Bind вот так:

Bind(1, fun x ->
Bind(2, fun y ->
Bind(x + y, fun z ->
// и т.д.

Думаю, вы уже поняли, к чему я веду.

Действительно, наша функция pipeInfo (из прошлого поста) — то же самое, что и метод Bind.

Ключевая мысль: вычислительное выражение — это упрощённая запись вещей, которые мы и так можем делать.

Функция bind под микроскопом

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

Во-первых, почему она называется "bind" (привязать, связывать)? Ну, как мы видели, функцию или метод "bind" можно рассматривать, как передачу входного значения в функцию. Этот процесс известен, как "связывание" значения с параметром функции (помним, что в функциональных языках все функции можно привести к виду, когда они получают только один параметр — эта штука называется каррирование).

Если смотреть на связывание с этой точки зрения, оно напоминает конвейер или композицию функций.

Вы и правда можете превратить его в инфиксный оператор:

let (>>=) m f = pipeInto(m,f)

Кстати, символ ">>=" — стандартная запись связывания в виде инфиксного оператора. Если вы когда-нибудь видели её в F#-коде, скорее всего, вы видели именно связывание.

Вернёмся к примеру с безопасным делением, и перепишем логику в одну строку:

let divideByWorkflow x y w z =
    x |> divideBy y >>= divideBy w >>= divideBy z

Вам, возможно, интересно, чем именно связывание отличается от обычного конвейера или композиции? Это не так очевидно.

Ответ здесь двойной:

Во-первых, функция bind делает дополнительную работу, разную в разных ситуациях. Это не универсальная функция, как конвейер или композиция.
Во-вторых, тип входного параметра (m выше) не обязательно совпадает с типом результата функции (f выше), так что одна из вещей, которую делает bind — это элегантная обработка несоответствия типов, благодаря которой вызовы bind можно объединять в цепочку.

Как мы увидим в следующем посте, связывание в целом работает на базе какого-то типа-обёртки. Типом параметра может быть WrapperType<TypeA>, а сигнатурой функционального параметра функции bind будет TypeA -> WrapperType<TypeB>.

В случае bind для безопасного деления, типом-обёрткой является Option. Тип входного параметра (выше m) — Option<int>, а сигнатура функционального параметре (выше f) — int -> Option<int>.

Чтобы увидеть связывание в разных контекстах, приведём пример логирования, работающий посредством инфиксной функции bind:

let (>>=) m f =
    printfn "expression is %A" m
    f m

let loggingWorkflow =
    1 >>= (+) 2 >>= (*) 42 >>= id

Здесь нет даже типа-обёртки, используется только int. Но и здесь у bind есть специальное поведение — логирование — которое выполняется под капотом (или за кулисами, как вам больше нравится).

Option.bind: ещё раз про обработку опциональных значений

В библиотеке F# вы не раз встретите функции или методы Bind. Теперь вы знаете, зачем они нужны!

Особенно полезна функция Option.bind, которая делает в точности то, что мы написали выше, а именно

Если входной параметр имеет значение None, она не вызывает функцию-продолжение.
Если входной параметр имеет значение Some, она вызывает функцию-продолжение, передавая ей содержимое Some.

Так выглядела функция, которую мы написали сами:

let pipeInto (m,f) =
   match m with
   | None ->
       None
   | Some x ->
       x |> f

А так выглядит реализация Option.bind:

module Option =
    let bind f m =
       match m with
       | None ->
           None
       | Some x ->
           x |> f

Вот и мораль — не торопитесь писать свои функции. Может оказаться, что они давно есть в библиотеке!

Вот методы класса-построителя опционального типа, реализованные через Option.bind:

type MaybeBuilder() =
    member this.Bind(m, f) = Option.bind f m
    member this.Return(x) = Some x

Сравнение подходов

На данный момент мы использовали четыре различных подхода в примере с "безопасным делением". Давайте ещё раз сравним их строка за строкой.

Примечание: я переименовал оригинальную функцию pipeInfo в bind и использовал Option.bind вместо оригинальной самописной реализации.

Для начала взглянем на оригинальную версию, явно описывающую весь процесс:

module DivideByExplicit =

    let divideBy bottom top =
        if bottom = 0
        then None
        else Some(top/bottom)

    let divideByWorkflow x y w z =
        let a = x |> divideBy y
        match a with
        | None -> None  // прерываем
        | Some a' ->    // продолжаем
            let b = a' |> divideBy w
            match b with
            | None -> None  // прерываем
            | Some b' ->    // продолжаем
                let c = b' |> divideBy z
                match c with
                | None -> None  // прерываем
                | Some c' ->    // продолжаем
                    // возврат
                    Some c'
    // проверяем
    let good = divideByWorkflow 12 3 2 1
    let bad = divideByWorkflow 12 3 0 1

Теперь — на версию с самописной функцией bind (которую мы называли pipeInfo):

module DivideByWithBindFunction =

    let divideBy bottom top =
        if bottom = 0
        then None
        else Some(top/bottom)

    let bind (m,f) =
        Option.bind f m

    let return' x = Some x

    let divideByWorkflow x y w z =
        bind (x |> divideBy y, fun a ->
        bind (a |> divideBy w, fun b ->
        bind (b |> divideBy z, fun c ->
        return' c
        )))

    // проверяем
    let good = divideByWorkflow 12 3 2 1
    let bad = divideByWorkflow 12 3 0 1

Далее на версию с вычислительным выражением:

module DivideByWithCompExpr =

    let divideBy bottom top =
        if bottom = 0
        then None
        else Some(top/bottom)

    type MaybeBuilder() =
        member this.Bind(m, f) = Option.bind f m
        member this.Return(x) = Some x

    let maybe = new MaybeBuilder()

    let divideByWorkflow x y w z =
        maybe
            {
            let! a = x |> divideBy y
            let! b = a |> divideBy w
            let! c = b |> divideBy z
            return c
            }

    // проверяем
    let good = divideByWorkflow 12 3 2 1
    let bad = divideByWorkflow 12 3 0 1

И, наконец, на версию с bind в качестве инфиксного оператора:

module DivideByWithBindOperator =

    let divideBy bottom top =
        if bottom = 0
        then None
        else Some(top/bottom)

    let (>>=) m f = Option.bind f m

    let divideByWorkflow x y w z =
        x |> divideBy y
        >>= divideBy w
        >>= divideBy z

    // test
    let good = divideByWorkflow 12 3 2 1
    let bad = divideByWorkflow 12 3 0 1

Функции связывания оказываются очень мощными. В следующем посте мы увидим, как комбинирование bind с типом-обёрткой позволяет элегантно и при этом неявно передавать дополнительную информацию.

Упражнение: Насколько вы разобрались в материале?

Перед тем, как двинуться дальше, почему бы вам не проверить, насколько хорошо вы поняли всё, что мы обсудили к этому моменту?

Вот для вас небольшое упражнение.

Часть 1 — реализуйте процесс

Для начала напишите функцию, которая преобразует строку в целое число:

let strToInt str = ???

и затем — класс-построитель вычислительного выражения, такой, чтобы его можно было использовать в программе, показанной ниже.

let stringAddWorkflow x y z =
    yourWorkflow
        {
        let! a = strToInt x
        let! b = strToInt y
        let! c = strToInt z
        return a + b + c
        }

// проверяем
let good = stringAddWorkflow "12" "3" "2"
let bad = stringAddWorkflow "12" "xyz" "2"

Часть 2 — напишите функцию bind

Как только ваш код заработает, расширьте его, добавив две новых функции:

let strAdd str i = ???
let (>>=) m f = ???

Теперь, с помощью этих функций вам будет нетрудно переписать код в таком стиле:

let good = strToInt "1" >>= strAdd "2" >>= strAdd "3"
let bad = strToInt "1" >>= strAdd "xyz" >>= strAdd "3"

Заключение

Вот о чём, в двух словах, мы говорили в этом посте:

Вычислительные выражения — это красивый синтаксис для программирования через передачу продолжений, скрывающий от нас вложенность когда.
bind — ключевая функция которая связывает выход, полученный на текущем шаге с входом следующего шага.
Символ ">>=" — стандартная запись bind в виде инфиксного оператора.

Вычислительные выражения: Введение в 'Bind'