.net - Combinando Predicados en F#

functional-programming composition

Question

¿Hay una forma estándar de combinar lógicamente los predicados en F #? Por ejemplo, digamos que tengo isCar x y isBlue x entonces quiero algo que me dé:

let isBlueCar x = isCar x && isBlue x

Pero usar algún tipo de composición, en lugar de invocación, tal vez como:

let isBlueCar x = isCar && isBlue

Preferiblemente, ese algo sería capaz de aceptar un número grande / arbitrario de predicados.

Answer 1

¿Es esto lo que estás buscando?

> let (&&<) a b x = a x && b x

val ( &&< ) : (''a -> bool) -> (''a -> bool) -> ''a -> bool

> let isBlueCar = isCar &&< isBlue

val isBlueCar : (int -> bool)

Answer 2

Podrías definir un combinador.

let (<&>) f g = (fun x -> f x && g x)

entonces hazlo

let isBlueCar = isCar <&> isBlue

Answer 3

Podrías hacer algo como lo siguiente:

let predicates = [isCar; isBlue]
let isBlueCar x = predicates |> List.forall (fun predicate -> predicate x)

Más generalmente:

let combinePredicates predicates =
    fun x -> predicates |> List.forall (fun predicate -> predicate x)

let isBlueCar = combinePredicates [isCar;isBlue]

Answer 4

let meetsAll preds = preds |> Seq.fold (fun p q x -> p x && q x) (fun _ -> true)
// or     let meetsAll preds x = preds |> Seq.forall (fun p -> p x)

como en

let isEven x = x%2 = 0
let isDiv5 x = x%5 = 0
let isDiv7 x = x%7 = 0

let div257 = meetsAll [isEven; isDiv5; isDiv7]

for i in 1..100 do
    if div257 i then
        printfn "%d" i

No hay una función de biblioteca estándar para ello, pero hay una gran cantidad de líneas de unipersonal que puede definir por su cuenta, como lo demuestran las respuestas aquí.