# quicksort
- fun partiziona nil a = (nil, nil)
   |  partiziona (h::t) a =      
          let val (p1, p2) = partiziona t a
          in if a>h then (h::p1, p2) else (p1, h::p2)
          end;
> val partiziona = fn : int list -> int -> int list * int list


- fun quicksort nil = nil
   |  quicksort (h::t) = 
          let val (p1, p2) = partiziona t h
          in append (quicksort p1) (h::(quicksort p2))
          end;
> val quicksort = fn : int list -> int list

# quicksort generico: funziona su tutti i tipi. E' necessario passare
# come parametro la relazione secondo cui si ordina.
fun partizionaGen   nil  a min = (nil, nil)
 |  partizionaGen (h::t) a min =
          let val (p1, p2) = partizionaGen t a min
              in if (min h a) then (h::p1, p2) else (p1, h::p2)
          end;
> val ('a, 'b) partizionaGen = fn :
  'a list -> 'b -> ('a -> 'b -> bool) -> 'b list * 'b list

fun quicksortGen   nil  min = nil
 |  quicksortGen (h::t) min =
          let val (p1, p2) = partizionaGen t h min
              in append (quicksortGen p1 min) (h::(quicksortGen p2 min))
          end;
> val ('a, 'b) quicksortGen = fn :'a list -> ('a -> 'a -> bool) -> 'a list

# miracoli dell'ordine superiore... ammirare senza capire... 
fun prodMatr A B = 
     map 
       (fn x=>(map 
                   (fn y=>prodottoScalare x y) 
                   (trasposta B)
             )) 
       A;
> val it = fn : int list list -> int list list -> int list list

# se proprio si vuole anche capire cominciare a pensare come 
# ottenere una riga della matrice risultato:
# moltiplicando una riga R per tutte le colonne... quindi:
# map (fn y=> prodottoScalare R (trasposta B)
# a questo punto per ottenere il prodotto bisogna astrarre su R
# fn x => map (fn y=> prodottoScalare x (trasposta B) 
# e mappare la funzione ottenuta su tutte le righe della matrice originale... 
# innaturale? forse, pero' divertente!
# in fondo, il map, concretamente e' un ciclo per scorrere una lista...