F# 与查询结果匹配。 有没有一种优雅的方式来做到这一点？

Question

I have an result of a JObject type, from parsing json:

let j = JObject.Parse x

the code I have to do is like:

if j = null then
    ... do stuff
else if j["aa"] <> null then
    ... do stuff
else if j["bb"] <> null then
    ... do stuff
else if j["cc"] <> null and j["dd"] <> null then
    ... do stuff

is there a clean way to do this match?

doing statements like

| _ when j.["error"] <> null ->

doesn't seem super clean. Can this be done better?

Answer 1

1. To do something for the first non-null value:

    let j = JObject.Parse x
    let doSomething s = printf "%A" s
    if isNull j then
        ()
    else
        [ j.["aa"]; j.["bb"]; j.["cc"] ]
        |> List.tryFind (fun s -> s |> Option.ofObj |> Option.isSome)
        |> doSomething

2. Or do something for each non-null value:

    let j = JObject.Parse x
    let doSomething s = printf "%A" s
    if isNull j then
        ()
    else
        [ j.["aa"]; j.["bb"]; j.["cc"] ]
        |> List.choose (fun s -> s |> Option.ofObj)
        |> List.iter doSomething

3. Or do something different (depending on which value is non-null) for the first non-null value:

    let j = JObject.Parse x
    let doSomethingA s = printf "%A" s
    let doSomethingB s = printf "%A" s
    let doSomethingC s = printf "%A" s
    if isNull j then
        ()
    else
        [ 
            j.["aa"], doSomethingA
            j.["bb"], doSomethingB
            j.["cc"], doSomethingC
        ]
        |> List.tryFind (fun (s, _) -> s |> Option.ofObj |> Option.isSome)
        |> Option.iter (fun (s, f) -> f s)

Answer 2

If you create an active pattern that returns the matched JToken ...

let (|NonNull|_|) prop (o : JObject) =
    o.[prop] |> Option.ofObj

you could write something like:

let handleAA (a : JToken) = ()

match JObject.Parse "{}" with
| null -> () // ...
| NonNull "aa" a -> handleAA a
| NonNull "bb" b & NonNull "cc" c -> ()
| _ -> () // all other

Update

If you need more power, Active Patterns galore...

let (|J|_|) prop (o : obj) =
    match o with
    | :? JObject as o -> o.[prop] |> Option.ofObj
    | _ -> None

let (|Deep|_|) (path : string) (o : obj) =
    let get t p = t |> Option.bind (fun t -> (``|J|_|``) p t)
    match o with
    | :? JToken as t ->
        path.Split('.') |> Array.fold get (Option.ofObj t)
    | _ -> None

... some helpers...

let jV (t : JToken) = t.Value<string>()
let handle t = jV t |> printfn "single: %s"
let handle2 a b = printfn "(%s, %s)" (jV a) (jV b)

... a parse function...

let parse o =
    match JsonConvert.DeserializeObject o with
    | null -> printfn "null"
    | J "aa" a -> handle a
    | J "bb" b & J "cc" c -> handle2 b c
    | J "bb" b & J "dd"  _ -> handle b
    | Deep "foo.bar" bar & Deep "hello.world" world -> handle2 bar world
    | Deep "foo.bar" bar -> handle bar
    | o -> printfn "val: %A" o

... and off we go:

parse "null" // null
parse "42" // val: 42L
parse "{ aa: 3.141 }" // single: 3.141
parse "{ bb: 2.718, cc: \"e\" }" // (2.718, e)
parse "{ bb: 2.718, dd: 0 }" // single: 2.718
parse "{ foo: { bar: \"baz\" } }" // single: baz
parse "{ foo: { bar: \"baz\" }, hello: { world: \"F#|>I❤\" } }" // (baz, F#|>I❤)

Answer 3

You could create an active pattern to match non-null values...

let (|NonNull|_|) = function null -> None | v -> Some v

...which would allow the following.

if isNull j then
    //do stuff
else
    match j.["aa"], j.["bb"], j.["cc"], j.["dd"] with
    | NonNull aa, _, _, _ -> //do stuff
    | _, NonNull bb, _, _ -> //do stuff
    | _, _, NonNull cc, NonNull dd -> //do stuff

Answer 4

You could make a list of actions for each key so you could apply the null checking logic uniformly for each one.

let j = JObject.Parse x
let doStuff key value = printfn "%s=>%s" key value

If you wanted to apply doStuff for every key you could iterate though. This is your example but without the else so it does it for every key present.

  ["aa", doStuff
   "bb", doStuff
   "cc", doStuff]
  |> List.iter (fun (key,action) -> 
    j.TryGetValue key
    |> snd
    |> Option.ofObj
    |> Option.iter (action key))

Matching your example more closely where you only doStuff for the first key present might use choose to get only the valid values,actions.

  ["aa", doStuff
   "bb", doStuff
   "cc", doStuff]
   |> Seq.choose (fun (key,action) ->
      j.TryGetValue key
      |> snd
      |> Option.ofObj
      |> Option.map (fun v -> action key v))
   |> Seq.tryHead

This version also returns the result of the applied doStuff if there was a matching key and doStuff returned a value. This is abusing the lazy nature of Seq a little bit to only call the first value but you could also map to a function an call the result of Seq.tryHead.

Answer 5

Option.ofObj will turn null -> None and v -> Some v

Since JObject is enumerable you can just map over it

let j = JObject.Parse x |> Seq.map Option.ofObj
// j.["aa"] is an Option type now, map will only multiply the value by 3 if it exists
// otherwise it will return none. 
let aa = j.["aa"] |> Option.map (fun a -> a * 3)