Как я могу реорганизовать требуемое условие else?

Question

У меня есть метод C#, который выглядит немного как это:

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 # это заканчивает тем, что совсем немного уродливее из обязательных либо еще филиалов:

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 #?

Answer 1

Ну, так как «делать какую-то работу» уже императив (предположительно), то я думаю, что

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

короче и разумно. (Другими словами, else является обязательным только для if выражений, которые возвращают значения, так как вы делаете императивный работу, использовать if заявления, которые не нуждаются в else.)

Answer 2

Использование функций высшего порядка в Option модуле может сделать этот поток очень чисто без изменяемого состояния:

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 

Или для большей ясности, используя названные функции, а не лямбды:

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

Пожалуйста, не бойтесь извлекать функции. Это ключ к управлению сложной логикой.

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 # не имеет императивные возвращается (если вы хотите, чтобы вернуться, вам нужно как истинные и ложные ветви), он на самом деле упрощает этот код немного слишком, потому что вы можете написать:

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 

вы все еще должны написать false несколько раз, но, по крайней мере, вы не должны отступы ваш код слишком далеко. Существует неограниченное количество сложных решений, но это, вероятно, самый простой вариант. Что касается более сложного решения, вы можете использовать F# computation expression that allows using imperative-style returns. Это похоже на вычисление Даниила, но немного более мощное.

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;