Come posso rifattorizzare la clausola else richiesta?

Question

Ho un metodo C# che sembra un po 'come questo:

bool Eval() { 
    // do some work 
    if (conditionA) { 
    // do some work 
    if (conditionB) { 
     // do some work 
     if (conditionC) { 
     // do some work 
     return true; 
     } 
    } 
    } 
    return false; 
} 

In F # questo finisce per guardare un bel po' più brutta a causa dei rami obbligatorie altro:

let eval() = 
    // do some work 
    if conditionA then 
    // do some work 
    if conditionB then 
     // do some work 
     if conditionC then 
     // do some work 
     true 
     else 
     false 
    else 
     false 
    else 
    false 

Quale potrebbe essere un pulitore modo di scrivere questo in F #?

Answer 1

Ebbene, dal momento che 'fare un certo lavoro' è già imperativo (presumibilmente), allora penso che

let eval() = 
    let mutable result = false 
    ... // ifs 
     result <- true 
    ... // no more elses 
    result 

è più breve e ragionevole. (In altre parole, else è obbligatorio solo per i if espressioni che restituiscono valori, in quanto si sta facendo un lavoro indispensabile, utilizzare if dichiarazioni che non hanno bisogno di un else.)

Answer 2

Utilizzando le funzioni di ordine superiore nel modulo Option può rendere questo flusso molto pulito senza alcun stato mutevole:

let Eval() = 
    // do some work 
    if not conditionA then None else 
     // do some work 
     Some state 
    |> Option.bind (fun state -> 
     if not conditionB then None else 
      // do some work 
      Some state') 
    |> Option.bind (fun state -> 
     if not conditionC then None else 
      // do some work 
      Some true) 
    |> defaultArg <| false 

O per maggiore chiarezza, utilizzando denominate funzioni, piuttosto che lambda:

let Eval() = 
    let a() = 
     if not conditionA then None else 
      // do some work 
      Some state 
    let b state = 
     if not conditionB then None else 
      // do some work 
      Some state' 
    let c state = 
     if not conditionC then None else 
      // do some work 
      Some true 
    // do some work 
    a() |> Option.bind b |> Option.bind c |> defaultArg <| false 

Answer 3

Si prega di non aver paura di estrarre le funzioni. Questa è la chiave per controllare la logica complessa.

let rec partA() = 
    // do some work 
    let aValue = makeA() 
    if conditionA 
    then partB aValue 
    else false 
and partB aValue = 
    // do some work 
    let bValue = makeB aValue 
    if conditionB 
    then partC bValue 
    else false 
and partC bValue = 
    // do some work 
    conditionC 

Answer 4

module Condition = 
    type ConditionBuilder() = 
    member x.Bind(v, f) = if v then f() else false 
    member x.Return(v) = v 
    let condition = ConditionBuilder() 

open Condition 

let eval() = 
    condition { 
    // do some work 
    do! conditionA 
    // do some work 
    do! conditionB 
    // do some work 
    do! conditionC 
    return true 
    } 

Answer 5

Come accennato nei commenti, si potrebbe invertire la condizione. Questo semplifica il codice C#, perché si può scrivere:

if (!conditionA) return false; 
// do some work 

Sebbene F # non ha resi imperativi (se si desidera tornare, è necessario entrambi i rami vere e false), in realtà semplifica questo codice un po 'troppo, perché si può scrivere:

let eval() = 
    // do some work 
    if not conditionA then false else 
    // do some work 
    if not conditionB then false else 
    // do some work 
    if not conditionC then false else 
    // do some work 
    true 

Hai ancora scrivere false più volte, ma almeno non si dispone di rientrare il codice di troppo. Esiste un numero illimitato di soluzioni complesse, ma questa è probabilmente l'opzione più semplice. Per quanto riguarda la soluzione più complessa, è possibile utilizzare uno F# computation expression that allows using imperative-style returns. Questo è simile al calcolo di Daniel, ma un po 'più potente.

Answer 6

Si potrebbe rendere il codice in una sorta di tabella di verità, che a seconda del caso nel mondo reale potrebbe rendere più esplicito:

let condA() = true 
let condB() = false 
let condC() = true 

let doThingA() = Console.WriteLine("Did work A") 
let doThingB() = Console.WriteLine("Did work B") 
let doThingC() = Console.WriteLine("Did work C") 

let Eval() : bool = 
    match condA(), condB(), condC() with 
    | true, false, _  -> doThingA();       false; 
    | true, true, false -> doThingA(); doThingB();    false; 
    | true, true, true -> doThingA(); doThingB(); doThingC(); true; 
    | false, _,  _  ->          false;