Write a binary-predicate list test
A binary-predicate is a function that tests a relation between two arguments. A binary-predicate has the general signature:
- : 'a -> 'a -> bool = <fun>
As examples = and && are both symmetric binary-predicates:
# (=);; - : 'a -> 'a -> bool = <fun> # (&&);; - : bool -> bool -> bool = <fun>
a) Implement exists_symmetric that tests if list contains distinct items x and y such that pred x y = pred y x = true.
let exists_symmetric pred list = ... ;;
val exists_symmetric : ('a -> 'a -> bool) -> 'a list -> bool = <fun>
b) There also exists asymmetric binary-predicates such as < and > :
# (>);; - : 'a -> 'a -> bool = <fun>
Implement exists_asymmetric that tests if list contains distinct items x and y such that (pred x y) or (pred y x) = true.
let exists_asymmetric pred list = ... ;;
val exists_asymmetric : ('a -> 'a -> bool) -> 'a list -> bool = <fun>
c) Let pattern be the following declared type:
type pattern = ... ;;
A sub-pattern is a less general, more specific pattern.
Two patterns are said to be unifiable iff there exist one pattern object that is a sub-pattern of both of them.
Let unifiable be the unifiability test:
let unifiable pat1 pat2 = ... ;; val unifiable : pattern -> pattern -> bool = <fun>
A choice is a list of patterns.
A choice is said to be determinist iff there exist no pattern object that is a sub-pattern of more than one pattern within the choice. That is iff there doesn't exist two patterns within the choice that are unifiable. Using exists_symmetric, implement determinist_choice that tests if a pat_list choice is determinist:
let determinist_choice pat_list = ... ;; val determinist_choice : pattern list -> bool = <fun>