Haskell / Ocaml duplicare lista

[CodiceProg]

Ad esempio avendo
l1=[1,2,3,4,5]
duplicare in una lista
l2=[15,1,3,6,10]
nel primo elemento la somma di tutti gli elementi della lista e nel resto la somma avanzando di posizione
Grazie in anticipo

[Scara95]

Perché vuoi il 15 per primo?

Haskell:

   sums = scanl1 (+)
   -- sums [1, 2, 3, 4, 5] -> [1, 3, 6, 10, 15]

  sums xs = last ss : init ss
    where
      ss = scan1 (+) xs
  -- sums [1, 2, 3, 4, 5] -> [15, 1, 3, 6, 10]
  -- meno efficiente

  sums (x:xs) = sums' [x] xs
    where
      sums' ss@(s:_) [x] = (s+x) : reverse ss
      sums' ss@(s:_) (x:xs) = sums' ((s+x):ss) xs
  -- a mano

[CodiceProg]

intanto,
grazie mille
che la somma totale come primo elemento lo richiede l' esercizio
la sintassi è Haskell?
e in Ocaml?

[Scara95]

E in ocaml fai esattamente la stessa cosa. Devi solo cambiare sintassi, non mi sembra un gran problema...

[CodiceProg]

certamente, era però come esempio di sintassi di Ocaml visto che non utilizzo il linguaggio

[Scara95]

certamente, era però come esempio di sintassi di Ocaml visto che non utilizzo il linguaggio

Scusa, ma allora a che ti serve sapere com'è quel codice in ocaml?

[Scara95]

molto gentile,
mi sorge ancora un dubbio, per fare ad esempio, duplicare se un elemento è maggiore del precedente,
si può utilizzare un pattern del tipo a::b::resto e controllare se b è > di a?

Puoi fare tutto quello che vuoi con il pattern matching...
Stai comunque sempre attento ai casi base e alle limitazioni del dominio

daccordo,
quindi quel frammento di codice è corretto?

Quale frammento di codice di preciso?

[CodiceProg]

no no,solo per questo "a::b::resto"

[Scara95]

no no,solo per questo "a::b::resto"

No no cosa?!

Comunque sì, è corretto, ma ti ripeto di controllare le limitazioni del dominio.

[CodiceProg]

mi scuso se riapro questa discussione dopo un pò di tempo,
dopo aver creato alcuni esempi positivamente con altre funzioni, sono tornato su questo codice

let rec sums ((s::_) as ss) xs =
  match xs with
    | []->[]
    | [x] -> (s+x) :: ss
    | (x::xs) -> sums ((s+x)::ss) xs;;

al momento dell' invocazione restituisce :
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
[]