AppuntiSML

(*File di riepilogo delle cose viste su sml*)

(*Eseguire un file sml*)
    (*use ("Riepilogo.sml");*)
(*Associare un valore ad un nome*)
    val a = 10;
    val b:char = #"a"; (*Specificando il tipo*)
(*Associare una funzione ad un nome*)
    val nome_funzione = fn n => n*2+1;
    nome_funzione (2);

    fun funzione n = n div 2;
    funzione (7);

(*Definire una funzione per casi*)
    fun pari_o_dispari n = case n mod 2 of 0 => "pari" | 1 => "dispari" ;
    pari_o_dispari 2;
    pari_o_dispari 3;

(*il case di default si effettua mediante il carattere wildcard _*)
(*Usando una sintassi ridotta"*)
    val pattern_match = fn 1 => "a" |
        2 => "b" |
        3 => "c" |
        _ => "z";
    pattern_match(1);
    pattern_match(2);
    pattern_match(3);
    pattern_match(4);

(*Definizione di una funzione ricorsiva*)
    val rec sum_first = fn n => if n = 0 then 0 else n + sum_first(n-1);
    sum_first 9;
(*Con fun non è necessario*)
    fun fact n = if n <= 0 then 1 else n * fact (n-1);
    fact 5;

(*SCOPE*)

    val y = 10;
    (fn x => x +y) 5; (*Utilizza il riferimento della y dichiarato nella riga precedente*)

    (*Costrutto let-in-end lavora su espressioni*)
    val fact = fn n =>
        let
            val rec fact_tail  = fn ( n , r) => if n = 0  (*Non visibile all'esterno*)
                then r
                else fact_tail(n-1,n*r)
        in
            fact_tail (n,1)
        end;

    (*Costrutto local-in-end lavora su dichiarazioni*)
    local
        fun succ n = n+1;  (*Non visibile all'esterno*)
    in
        fun succ_succ n = succ (succ n)
    end;
    succ_succ(10);

(*Funzioni di ordine superiore*)

    (*Funzione derivata che accetta come parametro una funzione da reali a reali e ne calcola la "derivata" in un punto passato come parametro *)
    val delta = 0.000001;
    fun derivata ( f , x) = (f(x + delta) - f(x))/(delta);
    derivata ( fn x => 2.0*x*x , 1.0);

    val f_derivata = fn f => ( fn x =>(f(x + delta) - f(x))/(delta) );

    f_derivata (fn n => n*n);
    (*Funzione che ritorna una funzione*)
    fun somma x = fn n => x+n;
    somma 1; (*Questa chiamata riturna una funzione fn:int -> int che somma 1 al parametro*)

    (*Curryng*)
        fun mul (x,y) = x*y; (*funzione da N*N a N *)
        mul(1,5);

        val mul_curr = fn x => fn y => x*y;(*funzione da N a (fn: N -> N) *)
        mul_curr 1 5;

        (*Come precedente usano sintassi semplificata*)
        fun mul_curr_semp x y = x*y;

(*Tipi di dato*)

    val tupola = ("a", 1, 1.5);

    (*Dare un nuovo nome a un tipo di dato esistente*)

    type indirizzo = string * int;
    val residenza : indirizzo = ("Piazza Dante" , 5);

    val conta_lettere_via  = fn (via   , n  ):indirizzo => (size via);
    conta_lettere_via residenza;