Question

如何从通用中检索值？

具体来说，我正在尝试以下方法：

// Test
let result = Validate goodInput;;

// How to access record??
let request = getRequest result

以下是代码：

type Result<'TSuccess,'TFailure> = 
    | Success of 'TSuccess
    | Failure of 'TFailure

let bind nextFunction lastFunctionResult = 
    match lastFunctionResult with
    | Success input -> nextFunction input
    | Failure f -> Failure f

type Request = {name:string; email:string}

let validate1 input =
   if input.name = "" then Failure "Name must not be blank"
   else Success input

let validate2 input =
   if input.name.Length > 50 then Failure "Name must not be longer than 50 chars"
   else Success input

let validate3 input =
   if input.email = "" then Failure "Email must not be blank"   
   else Success input;;

let Validate = 
    validate1 
    >> bind validate2 
    >> bind validate3;;

// Setup
let goodInput = {name="Alice"; email="abc@abc.com"}
let badInput = {name=""; email="abc@abc.com"};;

// I have no clue how to do this...
let getRequest = function
    | "Alice", "abc@abc.com" -> {name="Scott"; email="xyz@xyz.com"}
    | _ -> {name="none"; email="none"}

// Test
let result = Validate goodInput;;

// How to access record??
let request = getRequest result
printfn "%A" result

Answer 1

您的意思是如何从结果类型中提取记录？通过模式匹配，这就是你在bind中已经做过的事情。

let getRequest result = 
    match result with
    | Success input -> input 
    | Failure msg -> failwithf "Invalid input: %s" msg

let result = Validate goodInput
let record = getRequest result

这将返回记录或抛出异常。在您拥有Result之后，如何处理成功和失败案例，这可能会导致例外，或者将其变为选项，或者记录消息并返回默认值等。

Answer 2

这似乎是一个经常被问到的问题：如何从monadic值中获取值？我认为正确的答案是Mu。

monadic值值。

这就像问，如何从整数列表中获取值，例如[1;3;3;7]？

你没有;列表是值。

或许，那么，你认为名单不是歧视联盟;他们没有相互排斥的案例，如上面的Result<'TSuccess,'TFailure>。相反，请考虑一棵树：

type Tree<'a> = Node of Tree<'a> list | Leaf of 'a

这是另一个被歧视的联盟。例子包括：

let t1 = Leaf 42
let t2 = Node [Node []; Node[Leaf 1; Leaf 3]; Node[Leaf 3; Leaf 7]]

如何从树中获取价值？你没有;树是的值。

与F＃中的'a option一样，上述Result<'TSuccess,'TFailure>类型（实际上，它是 Either monad）具有欺骗性，因为它似乎应该只有一个价值：成功。我们不想思考的失败（就像我们不想考虑None）。

然而，这种类型并不是那样的。失败案例与成功案例同样重要。 Either monad通常用于模拟错误处理，它的全部内容是使用类型安全方式来处理错误，而不是异常，这些异常只是专门的，非确定性的GOTO块。

这就是the Result<'TSuccess,'TFailure> type comes with bind, map, and lots of other goodies。

的原因

monadic类型是Scott Wlaschin calls an 'elevated world'。当您使用该类型时，您不应该从该世界中提取数据。相反，你应该将数据和功能提升到那个世界。

回到上面的代码，假设给定有效的Request值，您希望向该地址发送电子邮件。因此，您编写以下（不纯）函数：

let send { name = name; email = email } =
    // Send email using name and email

此函数的类型为Request -> unit。请注意，它的不升级到了Either世界。不过，如果请求有效，您仍希望发送电子邮件，因此您将send方法提升到了Either世界：

let map f = bind (fun x -> Success (f x))
let run = validate1 >> bind validate2 >> bind validate3 >> map send

run函数的类型为Request -> Result<unit,string>，因此与goodInput和badInput一起使用，结果如下：

> run goodInput;;
val it : Result<unit,string> = Success unit
> run badInput;;
val it : Result<unit,string> = Failure "Name must not be blank"

然后你可能会问：我如何从中获得价值？

该问题的答案完全取决于您想要对该值执行的操作，但是，假设您要将run的结果报告给用户。向用户显示内容通常涉及一些文本，您可以轻松地将结果转换为string：

let reportOnRun = function
    | Success () -> "Email was sent."
    | Failure msg -> msg

此函数的类型为Result<unit,string> -> string，因此您可以使用它来报告任何结果：

> run goodInput |> reportOnRun;;
val it : string = "Email was sent."
> run badInput |> reportOnRun;;
val it : string = "Name must not be blank"

在所有情况下，您都会获得可以向用户显示的string。

如何从复合泛型类型中检索值？

2 个答案: