def RemoveFirst(As, value):
""" Rimuovi il primo elemento di 'value' trovato in As """
if IsEmpty(As):
return As
if Head(As) == value:
return Tail(As)
return MakeList(Head(As), RemoveFirst(Tail(As), value))
def RemoveAll(As, value):
""" Rimuovi tutti gli elementi di 'value' trovato in As """
if IsEmpty(As):
return As
if Head(As) == value:
return RemoveAll(Tail(As), value)
return MakeList(Head(As), RemoveAll(Tail(As), value))
def Filter(P, As):
""" Restituisci una nuova lista che contiene solo gli elementi di As
che soddisfano il predicato P() """
if IsEmpty(As):
return As
if P(Head(As)):
return MakeList(Head(As), Filter(P, Tail(As)))
return Filter(P, Tail(As))
def Equal(As, Bs):
""" Check if two lists have the same sequence of elements """
if IsEmpty(As) and IsEmpty(Bs):
return True
if IsEmpty(As) and not IsEmpty(Bs):
return False
if not IsEmpty(As) and IsEmpty(Bs):
return False
if Head(As) != Head(Bs):
return False
return Equal(Tail(As), Tail(Bs))
def Nth(As, i):
""" Restituisce l'i-esimo elemento della lista As """
if IsEmpty(As):
return As
if i == 0:
return Head(As)
return Nth(Tail(As), i - 1)
def Contains(As, value):
""" Controlla se la lista As contiene un elemento pari a 'value' """
if IsEmpty(As):
return False
if Head(As) == value:
return True
return Contains(Tail(As), value)
def Reverse(As):
""" Restituisci una nuova lista gli elemento di As in ordine inverso """
def ReverseI(Ls, Rs):
if IsEmpty(Tail(Ls)):
return MakeList(Head(Ls), Rs)
return ReverseI(Tail(Ls), MakeList(Head(Ls), Rs))
return ReverseI(Tail(As), MakeList(Head(As)))
def PrintListI(As):
if not IsEmpty(As):
print(Head(As), end='')
if not IsEmpty(Tail(As)):
print(', ', end='')
PrintListI(Tail(As))
def Max(As):
""" Più grande elemento della lista As """
return Fold(max, Tail(As), Head(As))
def Min(As):
""" Più piccolo elemento della lista As """
return Fold(min, Tail(As), Head(As))
def FoldLeft(Op, As, z):
if IsEmpty(As):
return z
return FoldLeft(Op, Tail(As), Op(Head(As), z))
def Map(F, As):
""" Restituisci una nuova lista che per ogni elemento di As
contiene il valore ottenuto applicato F() ad all'elemento """
if IsEmpty(As):
return As
return MakeList(F(Head(As)), Map(F, Tail(As)))
def CountI(Ls, counter):
if IsEmpty(Ls):
return counter
if Head(Ls) == value:
return CountI(Tail(Ls), counter + 1)
return CountI(Tail(Ls), counter)
def ReverseI(Ls, Rs):
if IsEmpty(Tail(Ls)):
return MakeList(Head(Ls), Rs)
return ReverseI(Tail(Ls), MakeList(Head(Ls), Rs))
def Append(As, Bs):
""" Aggiungi la lista Bs in coda alla lista As """
if IsEmpty(As):
return Bs
return MakeList(Head(As), Append(Tail(As), Bs))
def FoldRight(Op, As, z):
""" Riduci la lista As, applicando ad ogni suo elemento la funzione F()
e accumulando i risultati tramite l'operazione Op() """
if IsEmpty(As):
return z
return Op(Head(As), FoldRight(Op, Tail(As), z))
def Scala(As, a):
""" Restituisci una nuova lista che per ogni elemento di As
contiene lo stesso valore moltiplicato per 'a' """
if IsEmpty(As):
return As
return MakeList(a * Head(As), Scala(Tail(As), a))
def Quadrati(As):
""" Restituisci una nuova lista che per ogni elemento di As
contiene lo stesso valore al quadrato """
if IsEmpty(As):
return As
return MakeList(Head(As) * Head(As), Quadrati(Tail(As)))