どのようにして必要なelse節をリファクタリングできますか？

Question

私は少しこのようになりますC＃の方法があります。

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 

きれいになり何：これが原因で必須、他の枝のかなり醜い探して終わるF＃では

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

をF＃でこれを書く方法？

Answer 1

まあは、「いくつかの作業を行う」（おそらく）すでに不可欠であることから、その後、私は

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

が短くかつ合理的であると思います。 （言い換えれば、elseは値のみを返すif表現には必須であり、あなたは絶対に必要な作業をやっているので、else必要がないことifステートメントを使用）Optionモジュールに高階関数を使用して

Answer 2

を

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 

：という名前の関数ではなく、ラムダを使用して、

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 

それともさらに明確にするため：任意の可変状態なく、非常にきれいにこの流れを作ることができます

Answer 3

機能を抽出することを恐れないでください。これは、複雑なロジックを制御する上で重要です。

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

コメントで述べたように、あなたは条件を反転できます。あなたが書くことができるので、これは、C＃のコードを簡素化：

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

F＃は（あなたが返すようにしたい場合、あなたは両方の真と偽の枝を必要とする）が不可欠リターンを持っていませんが、それは実際には、少しもこのコードを簡素化あなたはまだfalse複数回記述する必要がありますが、少なくとも、あなたはあまりにも遠く、あなたのコードをインデントする必要はありません

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 

：あなたが書くことができますので。無制限の複雑なソリューションがありますが、これはおそらく最も簡単なオプションです。より複雑なソリューションについては、F# computation expression that allows using imperative-style returnsを使用できます。これはDanielの計算と似ていますが、もう少し強力です。

Answer 6

あなたは、現実世界のケースに応じて、それがより明確にするかもしれない、真理値表のようなものにあなたのコードを作ることができる：

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;