Железнодорожное программирование с асинхронными операциями

Взгляните на исходный код Suave и, в частности, функция WebPart.bind. В Suave WebPart — это функция, которая принимает контекст («контекст» — это текущий запрос и ответ на данный момент) и возвращает результат типа Async<context option>. Семантика их объединения в цепочку заключается в том, что если async возвращает None, следующий шаг пропускается; если он возвращает Some value, следующий шаг вызывается с value в качестве входных данных. Это в значительной степени та же семантика, что и тип Result, так что вы можете почти скопировать код Suave и настроить его для Result вместо Option. Например, что-то вроде этого:

module AsyncResult

let bind (f : 'a -> Async<Result<'b, 'c>>) (a : Async<Result<'a, 'c>>)  : Async<Result<'b, 'c>> = async {
    let! r = a
    match r with
    | Ok value ->
        let next : Async<Result<'b, 'c>> = f value
        return! next
    | Error err -> return (Error err)
}

let compose (f : 'a -> Async<Result<'b, 'e>>) (g : 'b -> Async<Result<'c, 'e>>) : 'a -> Async<Result<'c, 'e>> =
    fun x -> bind g (f x)

let (>>=) a f = bind f a
let (>=>) f g = compose f g

Теперь вы можете написать свою цепочку следующим образом:

let chain = create >=> update >=> upload >=> publish
let result = chain(schemaObject) |> Async.RunSynchronously
match result with 
| Ok article -> Debug.WriteLine(article.name)
| Error error -> Debug.WriteLine(error.code + ":" + error.message)

Внимание: я не смог проверить этот код, запустив его в F# Interactive, так как у меня нет примеров вашего создания/обновления/и т.д. функции. В принципе, это должно работать — все типы подходят друг к другу, как строительные блоки Lego, и поэтому вы можете сказать, что код F#, вероятно, правильный — но если я сделал опечатку, которую компилятор уловил бы, я еще не знаю. знать об этом. Дайте мне знать, если это работает для вас.

Обновление: в комментарии вы спросили, нужно ли вам определить операторы >>= и >=>, и упомянули, что не видели их использования в коде chain. Я определил оба, потому что они служат разным целям, точно так же, как операторы |> и >> служат разным целям. >>= похож на |>: он передает значение в функцию. В то время как >=> похож на >>: он берет две функции и объединяет их. Если бы вы написали следующее в контексте, отличном от AsyncResult:

let chain = step1 >> step2 >> step3

Тогда это переводится как:

let asyncResultChain = step1AR >=> step2AR >=> step3AR

Где я использую суффикс «AR» для обозначения версий тех функций, которые возвращают тип Async<Result<whatever>>. С другой стороны, если бы вы написали это в стиле передачи данных через конвейер:

let result = input |> step1 |> step2 |> step3

Тогда это будет означать:

let asyncResult = input >>= step1AR >>= step2AR >>= step3AR

Вот почему вам нужны функции bind и compose, а также соответствующие им операторы: чтобы у вас был эквивалент операторов |> или >> для ваших значений AsyncResult.

Кстати, имена операторов, которые я выбрал (>>= и >=>), я выбрал не случайно. Это стандартные операторы, которые повсеместно используются для операций «привязки» и «составления» над такими значениями, как Async, Result или AsyncResult. Поэтому, если вы определяете свои собственные, придерживайтесь «стандартных» имен операторов, и другие люди, читающие ваш код, не будут сбиты с толку.

Обновление 2. Вот как читать подписи этих типов:

'a -> Async<Result<'b, 'c>>

Это функция, которая принимает тип A и возвращает Async, обернутый вокруг Result. Result имеет тип B в качестве случая успеха и тип C в качестве случая отказа.

Async<Result<'a, 'c>>

Это значение, а не функция. Это Async, обернутый вокруг Result, где тип A — это случай успеха, а тип C — случай отказа.

Итак, функция bind принимает два параметра:

• функция от A до асинхронного (либо B, либо C)).
• значение, которое является асинхронным (либо A, либо C)).

И он возвращает:

• значение, которое является асинхронным (либо B, либо C).

Глядя на эти сигнатуры типов, вы уже начинаете понимать, что будет делать функция bind. Он возьмет это значение, равное A или C, и "развернет" его. Если это C, то будет получено значение "либо B, либо C", равное C (и функцию вызывать не нужно). Если это A, то для преобразования его в значение «B или C» он вызовет функцию f (которая принимает A).

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

let bind (f : 'a -> Result<'b, 'c>) (a : Result<'a, 'c>) =
    match a with
    | Ok val -> f val
    | Error err -> Error err

В этом фрагменте тип val — 'a, а тип err — 'c.

Последнее обновление: во время сеанса чата был один комментарий, который, по моему мнению, стоит сохранить в ответе (поскольку люди почти никогда не переходят по ссылкам в чате). Разработчик11 спросил,

... если бы я спросил вас, что Result.bind в моем примере кода соответствует вашему подходу, можем ли мы переписать его как create >> AsyncResult.bind update? Однако это сработало. Просто интересно, мне понравилась краткая форма и, как вы сказали, они имеют стандартное значение? (в сообществе haskell?)

Мой ответ был:

да. Если оператор >=> написан правильно, то f >=> g всегда будет эквивалентен f >> bind g. На самом деле это именно то определение функции compose, хотя это может быть не сразу очевидно для вас, потому что compose пишется как fun x -> bind g (f x), а не как f >> bind g. Но эти два способа написания функции compose были бы полностью эквивалентны. Вероятно, для вас было бы очень поучительно сесть с листом бумаги и нарисовать функциональные «фигуры» (входы и выходы) обоих способов написания сочинения.

Почему вы хотите использовать железнодорожно-ориентированное программирование здесь? Если вы просто хотите запустить последовательность операций и вернуть информацию о первом возникшем исключении, то F# уже предоставляет языковую поддержку для этого с использованием исключений. Для этого вам не нужно железнодорожно-ориентированное программирование. Просто определите свой Error как исключение:

exception Error of code:string * message:string

Измените код, чтобы генерировать исключение (также обратите внимание, что ваша функция create принимает article, но не использует его, поэтому я удалил это):

let create () = async {  
    let ds = new DataContractJsonSerializer(typeof<Error>)
    let request = WebRequest.Create("http://example.com") :?> HttpWebRequest
    request.Method <- "GET"
    try
        use response = request.GetResponse() :?> HttpWebResponse
        use reader = new StreamReader(response.GetResponseStream())
        use memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(reader.ReadToEnd())) 
        return ds.ReadObject(memoryStream) :?> Article
    with
        | :? WebException as e ->  
        use reader = new StreamReader(e.Response.GetResponseStream())
        use memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(reader.ReadToEnd())) 
        return raise (Error (ds.ReadObject(memoryStream) :?> Error)) }

И тогда вы можете составлять функции, просто упорядочивая их в блоке async с помощью let! и добавляя обработку исключений:

let main () = async {
  try
    let! created = create ()
    let! updated = update created
    let! uploaded = upload updated
    Debug.WriteLine(uploaded.name)
  with Error(code, message) ->
    Debug.WriteLine(code + ":" + message) }

Если вам нужна более сложная обработка исключений, тогда может быть полезно программирование, ориентированное на железную дорогу, и, безусловно, есть способ интегрировать его с async, но если вы просто хотите делать то, что описали в своем вопросе, то вы можете сделать это намного проще с помощью просто стандартный F#.