Haskell / Ocaml duplicare lista

[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:
[]

[Scara95]

Il matching esterno presume che ci sia almeno un valore in ss. Ma la funzione che dovrebbe fare?!

[CodiceProg]

la funzione è quella delle pagine precedenti di questa discussione che mi avevi scritto gentilmente tu
Avendo una lista di interi e passandola alla funzione restituisce la lista con gli elementi con la somma progressiva
es.
[0,1,2,3,4,5] --> [0,1,3,6,10,15]

[Scara95]

[0,1,2,3,4,5] --> [0,1,3,6,10,15]

Quella funzione non fa ciò, io non ho mai scritto quello spezzone di codice, il waring è dato dalla pattern ((s::_) as ss) che fallisce per [], tuttavia nel mio codice una funzione con quella pattern veniva chiamata solo da un'altra funzione.

Questa è una soluzione che fa quello che chiedi.

let rev_scanl f a =
    let rec rev_scanl' f ((acc::_) as accs) xs = match xs with
       |[] -> accs
       |(y::ys) -> rev_scanl' f ((f acc y)::accs) ys
    in rev_scanl' f [a]
 
let rev_scanl1 f (x::xs) = rev_scanl f x xs
 
let sums xs = List.rev (rev_scanl1 (+) xs)

oppure, meno riutilizzabile,

let sums (x::xs) = 
    let rec sums' ((s::_) as ss) xs = match xs with
        | []->ss
        | (x::xs) -> sums' ((s+x)::ss) xs
    in List.rev (sums' [x] xs)

[CodiceProg]

perfetto gentilissimo,
sono una cosa, nel secondo codice restituisce :

Warning 8: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
[]
Characters 9-161:
.........(x::xs) =
let rec sums' ((s::_) as ss) xs = match xs with
| []->ss
| (x::xs) -> sums' ((s+x)::ss) xs
in List.rev (sums' [x] xs)..
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
[]


anche se poi il codice è comunque "utilizzabile"

[Scara95]

Ti ho già spiegato a che è dovuto: la pattern presume che ci sia almeno un valore nella lista, in quanto la funzione presume che ci sia almeno un valore nella lista e non è definita per liste nulle (ie [] ).

[CodiceProg]

quindi basta aggiungere []->[]?

[Scara95]

quindi basta aggiungere []->[]?

No. Quello non è un errore, è un warning che segnala che potresi aver tralasciato parte della soluzione. Ma la tua funzione prevede che ci sia almeno un elemento nella lista (dato che il primo valore dell'accumulatore non è 0, ma il primo elemento) per cui non ci sono problemi, a patto che non chiami la funzione con una lista vuota.

Sì. Se prevedi che nel caso la lista sia vuota non vi sia alcun valore nelle somme successive.

Dipende dalle specifiche della tua funzione. Tu hai dato come specifiche solo [0,1,2,3,4,5] --> [0,1,3,6,10,15]