Combinazione di predicati in F #

Question

Esiste un modo standard per combinare logicamente i predicati in F #? Per esempio, diciamo che ho isCar x e isBlue x poi voglio qualcosa che mi dà:

let isBlueCar x = isCar x && isBlue x 

Ma utilizzando una sorta di composizione, piuttosto che l'invocazione, forse come:

let isBlueCar x = isCar && isBlue 

Preferibilmente, che qualcosa sarebbe in grado di accettare un numero ampio/arbitrario di predicati.

Answer 1

È possibile definire un combinatore.

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

quindi fare

let isBlueCar = isCar <&> isBlue 

Answer 2

È questo quello che stai cercando?

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

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

> let isBlueCar = isCar &&< isBlue 

val isBlueCar : (int -> bool) 

Answer 3

Si potrebbe fare qualcosa di simile al seguente:

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

Più in generale:

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) 

come in

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 

Non v'è alcuna funzione di libreria standard per esso, ma ci sono una pletora di battute si può definire da soli, come dimostrano le risposte qui.