[Ocaml] Ancora problemi

[Sogeking_87]

Questa semplicissima funzione mi da' errore... Data una lista di quadruple e un intero, la funzione dovrebbe restituire una lista di interi, contenente quegli interi che sono in seconda posizione e in cui in prima posizione c'e' l'intero passato per argomento....

let rec crea (n,l1,g1) = match g1 with
	[] -> l1::[]
	| x::xs -> match x with (a,b,c,d) -> if a=n then crea(n,l1::b::[],xs)
					     else crea(n,l1,xs);;

L'errore è

Characters 110-112:
  	| x::xs -> match x with (a,b,c,d) -> if a=n then crea(n,l1::b::[],xs)
                                                           ^^
Error: This expression has type 'a list
       but an expression was expected of type 'a
       The type variable 'a occurs inside 'a list

[Scara95]

il problema è che a ogni chiamata stai cercando di aggiungere una lista ad una lista...
La soluzione è creare la lista al contrario e poi invertirla

let rec crea (n,l1,g1) = match g1 with
	[] -> List.rev l1
	| x::xs -> match x with (a,b,c,d) -> if a=n then crea(n,b::l1,xs)
					     else crea(n,l1,xs);;

Alternativamente puoi concatenare le due liste ad ogni passo, ma è (quasi) sicuramente meno efficiente

let rec crea (n,l1,g1) = match g1 with
	[] -> l1
	| x::xs -> match x with (a,b,c,d) -> if a=n then crea(n,l1@[b],xs)
					     else crea(n,l1,xs);;

Puoi anche utilizzare il seguente meccanismo, ma è a rischio di stack overflow

let rec crea (n,g1) = match g1 with
	[] -> []
	| x::xs -> match x with (a,b,c,d) -> if a=n then b::crea(n,xs)
					     else crea(n,xs);;

Puoi infine utilizzare la libreria standard (che però è a rischio di stack overflow)

let crea (n,g1) = List.map (fun (a,b,c,d) -> b) (List.filter (fun (a,b,c,d) -> a=n) g1)

Per risolvere il rischio di stack overflow potresti fare

let crea (n,g1) = List.rev (List.rev_map (fun (a,b,c,d) -> b) (List.filter (fun (a,b,c,d) -> a=n) g1))

Infine tieni conto che se la tua lista è breve non avrai alcun problema di stack overflow.
Ah, una nota! ad ogni chiamata della funzione ricorsiva crei e distruggi una tupla, potresti evitarlo. Inoltre le curried functions sono più conformi allo stile di ocaml e più comode da usare!

[Sogeking_87]

Non capisco nella tua seconda soluzione, perché funziona con la @ e non con ::
Concettualmente sembrerebbe giusto...
Ti prego aiutami a capire, altrimenti non ce la faccio ad andare avanti con questo progetto... Grazie mille per il tempo dedicatomi

[Scara95]

(@): 'a list -> 'a list -> 'a list 
(:: ) :'a -> 'a list -> 'a list

@ prende due liste e le concatena
:: apprende un elemento all'inizio della lista
Ciò si riflettere nei tipi e, di conseguenza, negli errori che ottieni...

Ripeto comunque che è il caso di evitare di concatenare le liste in quel modo a ogni ciclo...

[Sogeking_87]

E lui deduce che quella mia b è una lista e non un elemento da cosa?

[Scara95]

Analizzando il contesto, si chiama type inferring ed è una delle cose migliori mai inventate a mio parere!

[Sogeking_87]

mmmm... ok studiero' di piu' la teoria...
Ti ringrazio infinitamente... (p.s.) non escludo che questi giorni potro' avere altri problemi...

[Scara95]

Originariamente inviato da Sogeking_87
mmmm... ok studiero' di piu' la teoria...
Ti ringrazio infinitamente... (p.s.) non escludo che questi giorni potro' avere altri problemi...

tranquillo non c'è problema

Potrei sapere cosa stai realizzando?

[Sogeking_87]

Sto implementando l'algoritmo di Ford-Fulkerson sul flusso massimo all'interno di un grafo pesato... ma sono molto lontano dalla meta...

[Scara95]

Originariamente inviato da Sogeking_87
Sto implementando l'algoritmo di Ford-Fulkerson sul flusso massimo all'interno di un grafo pesato... ma sono molto lontano dalla meta...

Beh, buona fortuna