(********* Exercice 1 *********) import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.function.Consumer; import java.util.function.Predicate; class Client { public final String first_name; public final String last_name; public double size; public Client(String f, String l, double h) { first_name = f; last_name = l; size = h; } public String toString() { return first_name + last_name + " (" + size + ")"; } public void increase() { System.out.print("grows"); size *= 2; } public void roar() { if (size <= 5) System.out.print("mews"); else if(size <= 10) System.out.print("roars"); else System.out.print("*thunders*"); } } class Test { static Predicate andAll(List> lp) { if (lp.isEmpty()) { return (x) -> true; } else { Iterator> ip = lp.iterator(); Predicate p = ip.next(); while (ip.hasNext()) p = p.and(ip.next()); return p; } } static Consumer doAll(List> lc) { if (lc.isEmpty()) { return (x) -> {}; } else { Iterator> ic = lc.iterator(); Consumer c = ic.next(); while (ic.hasNext()) c = c.andThen(ic.next()); return c; } } public static void main(String[] args) { List clients = Arrays.asList( new Client("Allo", "Saurus", 8.5), new Client("Diplo", "Docus", 27), new Client("Draco", "Rex", 3), new Client("Mono", "Clonius", 5), new Client("Toy", "Sarus", 9.3) ); List> lp = Arrays.asList((x) -> (x.size >= 4), (x) -> (x.first_name.startsWith("D") || x.first_name.startsWith("T")), (x) -> (x.last_name.endsWith("us"))); Predicate p = andAll(lp); for (Client c : clients) { if (p.test(c)) System.out.println(c); } List> lc = Arrays.asList((x) -> { System.out.print(x); }, (x) -> { System.out.print(" "); x.roar(); }, (x) -> { System.out.print(", "); x.increase(); }, (x) -> { System.out.print(", and "); x.roar(); }, (x) -> { System.out.println(""); }); Consumer c = doAll(lc); for (Client d : clients) { c.accept(d); } } } (********* Exercice 2 *********) type complex = { re : float; im : float; plus : complex -> complex; mult : complex -> complex };; (* Version directe *) let rec new_complex r i = { re = r; im = i; plus = (fun z -> new_complex (r +. z.re) (i +. z.im)); mult = (fun z -> new_complex (r *. z.re -. i *. z.im) (i *. z.re +. r *. z.im)) };; (* Version avec fonctions currifiees compilees une seule fois *) let rec new_complex = let plus = (fun r i z -> new_complex (r +. z.re) (i +. z.im)) in let mult = (fun r i z -> new_complex (r *. z.re -. i *. z.im) (i *. z.re +. r *. z.im)) in fun r i -> { re = r; im = i; plus = plus r i; mult = mult r i };; (********* Exercice 3 *********) let my_list = [("sin",sin); ("cos",cos); ("plus",(fun x -> x+.1.))];; let rec remove_from_list list name = if (list=[]) then [] else let head = List.hd list in if ((fst head)=name) then remove_from_list (List.tl list) name else head::(remove_from_list (List.tl list) name);; remove_from_list my_list "sin";; (* - : (string * (float -> float)) list = [("cos", ); ("plus", )] *) let rec list_map f l = if (l=[]) then [] else (f(List.hd l))::(list_map f (List.tl l));; list_map fst my_list;; (* - : string list = ["sin"; "cos"; "plus"] *) (* Version recursive terminale maladroite, car on effectue *) (* des operations non recursives terminales a l'interieur des appels. *) let rec list_concatenate1 l1 l2 = if (l2=[]) then l1 else list_concatenate1 (l1@[List.hd l2]) (List.tl l2);; (* Version recursive terminale plus maline, passant par *) (* un double parcours de la liste. *) let list_concatenate2 l1 l2 = if (l2=[]) then l1 else let rec list_concatenate_rec m1 m2 = if (m1=[]) then m2 else list_concatenate_rec (List.tl m1) ((List.hd m1)::m2) in let nl1 = List.rev l1 in list_concatenate_rec nl1 l2;;