Question

在Scala中，有一个“部分函数”的概念，它与F＃的function关键字允许我实现的概念非常相似。但是，Scala的部分函数还允许通过orElse方法进行组合，如下所示：

def intMatcher: PartialFunction[Any,String] = {
  case _ : Int => "Int"
}

def stringMatcher: PartialFunction[Any,String] = {
  case _: String => "String"
}

def defaultMatcher: PartialFunction[Any,String] = {
  case _ => "other"
}

val msgHandler =
  intMatcher
  .orElse(stringMatcher)
  .orElse(defaultMatcher)

msgHandler(5) // yields res0: String = "Int"

我需要知道是否有一种方法可以在F＃中实现相同的合成功能。

Answer 1

我可能会在这里使用部分活动模式，那样您就可以使用模式匹配。某些（T）匹配，无匹配。

let (|Integer|_|) (str: string) =
   let mutable intvalue = 0
   if System.Int32.TryParse(str, &intvalue) then Some(intvalue)
   else None

let (|Float|_|) (str: string) =
   let mutable floatvalue = 0.0
   if System.Double.TryParse(str, &floatvalue) then Some(floatvalue)
   else None

let parseNumeric str =
   match str with
     | Integer i -> "integer"
     | Float f -> "float"
     | _ -> "other"

https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/active-patterns

但是值得注意的是，在这种人为情况下，您提供的仅可以使用单个match语句。我认为您的目标是将比赛条件拆分。

let msgHandler (x: obj) = 
    match x with
    | :? int -> "integer"
    | :? float -> "float"
    | _ -> "other"

Answer 2

在Scala中编写代码的方式等效于在C＃中使用扩展方法。对于函数式编程，它不是特别习惯。要在F＃中严格使用可组合函数，您可以执行以下操作。

// reusable functions
let unmatched input = Choice1Of2 input

let orElse f =
    function
    | Choice1Of2 input -> f input
    | Choice2Of2 output -> Choice2Of2 output

let withDefault value =
    function
    | Choice1Of2 _ -> value
    | Choice2Of2 output -> output

// problem-specific functions
let matcher isMatch value x =
    if isMatch x then Choice2Of2 value
    else Choice1Of2 x

let isInt (o : obj) = o :? int
let isString (o : obj) = o :? string

let intMatcher o = matcher isInt "Int" o
let stringMatcher o = matcher isString "String" o

// composed function
let msgHandler o =
    unmatched o
    |> orElse intMatcher
    |> orElse stringMatcher
    |> withDefault "other"

在这里，Choice1Of2表示我们尚未找到匹配项，并且包含不匹配的输入。 Choice2of2意味着我们找到了一个匹配项并包含输出值。

Answer 3

我想出了两种解决方案来实现自己的确切目标。一种是通过使用活动模式：

let orElse(fallback: 'a -> (unit -> 'b) option) (matcher: 'a -> (unit -> 'b) option) (arg:  'a) :  (unit -> 'b) option = 
    let first = matcher(arg)
    match first with
    | Some(_) -> first
    | None -> fallback(arg)

let (|StringCaseHandler|_|)(arg: obj) = 
    match arg with
    | :? string -> Some(fun () ->  "string")
    | _ -> None

let (|IntCaseHandler|_|)(arg: obj) = 
    match arg with
    | :? int -> Some(fun () ->  "integer")
    | _ -> None

let (|DefaultCaseHandler|_|)(arg: 'a) = 
    Some(fun () -> "other")

let msgHandler = 
    ``|StringCaseHandler|_|`` |> 
        orElse ``|IntCaseHandler|_|`` |> 
        orElse ``|DefaultCaseHandler|_|``

具有活动模式的解决方案是安全的，因为在没有适当匹配的情况下它不会抛出MatchFailureException；而是返回None。

第二个步骤涉及为类型'a -> 'b的函数定义扩展方法，并且也与Scala的“部分函数” orElse行为非常接近，如果结果函数不执行，则会抛出异常产生不正确的匹配：

[<Extension>]
type FunctionExtension() =
    [<Extension>]
    static member inline OrElse(self:'a -> 'b,fallback: 'a -> 'b) : 'a -> 'b = 
            fun arg -> 
                try 
                    self(arg) 
                with
                | :? MatchFailureException -> fallback(arg)

let intMatcher : obj -> string = function 
                                 | :? int -> "integer"
let stringMatcher : obj -> string = function 
                                    | :? string -> "string"
let defaultMatcher : obj -> string = function 
                                     | _ -> "other"

let msgHandler: obj -> string = intMatcher
                                    .OrElse(stringMatcher)
                                    .OrElse(defaultMatcher)

Scala的“部分函数”概念和F＃中的“ .orElse”方法

3 个答案: