Création d'expressions de calcul à l'aide d'unions discriminées à cas unique

Question

Si j'ai une fonction qui tente de diviser un nombre de départ deux fois. L'ensemble du flux de travail doit renvoyer un booléen.

let divideBy bottom top =
    if bottom = 0 then None
    else Some (top/bottom)

let divideByWorkflow init x y = 
    match init |> divideBy x with
    | None -> false
    | Some a -> 
        match a |> divideBy y with
        | None -> false
        | Some b -> true

let good = divideByWorkflow 12 3 2
let bad = divideByWorkflow 12 3 0

Le constructeur suivant est-il correct?

type BoolMaybe = BoolMaybe with
    member __.Bind (expr, f) =
        match expr with
        | Some value -> f value
        | None -> false
    member __.Return expr = expr

let divideByWorkflow init x y =
    BoolMaybe {
        let! a = init |> divideBy x
        let! b = a |> divideBy y
        return true
    }

.net f# pattern-matching monads computation-expression

2

MiP 21 avril 2017 à 10:13

Answer 1

Je suis d'accord avec la réponse de Dzoukr, la mienne est légèrement différente:

let divideBy bot top =
    match bot with
    | 0 -> None
    | _ -> Some (top / bot)

let divideByWorkflow init x y =
    Some init
    |> Option.bind (divBy x)
    |> Option.bind (divBy y)
    |> Option.isSome

Aucune expression de calcul requise, cela ne semble pas apporter d'avantages ici.

4

dumetrulo 21 avril 2017 à 09:27

Answer 2

IMHO il n'y a aucune raison de le rendre plus complexe en utilisant l'expression de calcul. Je préférerais rester avec quelques fonctions simples comme:

let divideBy bottom top =
    if bottom = 0 then None
    else Some (top/bottom)

let divideByTwoTimes init x y = 
    init |> divideBy x |> Option.bind (divideBy y)

let divideByWorkflow init x = divideByTwoTimes init x >> Option.isSome

3

Honza Brestan 21 avril 2017 à 08:57

Answer 3

Cela fonctionne, mais je pense que c'est inutilement spécifique. Si vous voulez utiliser un CE, je préfère définir un CE normal Maybe puis faire

let divideByWorkflow init x y =
    Maybe {
        let! a = init |> divideBy x
        let! b = a |> divideBy y
        return true
    }
    |> Option.defaultValue false

2

Tarmil 21 avril 2017 à 08:25

Création d'expressions de calcul à l'aide d'unions discriminées à cas unique

3 réponses

De nouvelles questions

.net