Resultados obtidos

O Result<'T,'TFailure> tipo permite escrever código tolerante a erros que pode ser composto.

Sintaxe

// The definition of Result in FSharp.Core
[<StructuralEquality; StructuralComparison>]
[<CompiledName("FSharpResult`2")>]
[<Struct>]
type Result<'T,'TError> =
    | Ok of ResultValue:'T
    | Error of ErrorValue:'TError

Observações

Consulte o Result módulo para os combinadores integrados para o Result. tipo.

Observe que o tipo de resultado é uma união discriminada struct. A semântica da igualdade estrutural aplica-se aqui.

O Result tipo é normalmente usado no tratamento de erros monádicos, que é muitas vezes referido como Programação Orientada a Ferrovias dentro da comunidade F#. O exemplo trivial a seguir demonstra essa abordagem.

// Define a simple type which has fields that can be validated
type Request =
    { Name: string
      Email: string }

// Define some logic for what defines a valid name.
//
// Generates a Result which is an Ok if the name validates;
// otherwise, it generates a Result which is an Error.
let validateName req =
    match req.Name with
    | null -> Error "No name found."
    | "" -> Error "Name is empty."
    | "bananas" -> Error "Bananas is not a name."
    | _ -> Ok req

// Similarly, define some email validation logic.
let validateEmail req =
    match req.Email with
    | null -> Error "No email found."
    | "" -> Error "Email is empty."
    | s when s.EndsWith("bananas.com") -> Error "No email from bananas.com is allowed."
    | _ -> Ok req

let validateRequest reqResult =
    reqResult
    |> Result.bind validateName
    |> Result.bind validateEmail

let test() =
    // Now, create a Request and pattern match on the result.
    let req1 = { Name = "Phillip"; Email = "phillip@contoso.biz" }
    let res1 = validateRequest (Ok req1)
    match res1 with
    | Ok req -> printfn $"My request was valid! Name: {req.Name} Email {req.Email}"  
    | Error e -> printfn $"Error: {e}"
    // Prints: "My request was valid!  Name: Phillip Email: phillip@consoto.biz"

    let req2 = { Name = "Phillip"; Email = "phillip@bananas.com" }
    let res2 = validateRequest (Ok req2)
    match res2 with
    | Ok req -> printfn $"My request was valid! Name: {req.Name} Email {req.Email}"  
    | Error e -> printfn $"Error: {e}"
    // Prints: "Error: No email from bananas.com is allowed."

test()

Como você pode ver, é muito fácil encadear várias funções de validação se você forçá-las todas a retornar um Resultarquivo . Isso permite que você divida funcionalidades como esta em pequenos pedaços que são tão componíveis quanto você precisa que eles sejam. Isso também tem o valor agregado de impor o uso de correspondência de padrões no final de uma rodada de validação, o que, por sua vez, impõe um maior grau de correção do programa.

Ver também

  • Last updated on