//Mutating meathod:
public static List <TA> Init(params TA[] a)
{
// If the list is empyty a empty Nil<TA> object is returned.
if (a.Length == 0)
{
return(Nil <TA> .GetNil());
}
// If the List isn't empty the new Cons object is called recursive, with the function Init.
// This Creates a nesed object, whith index 0 assigned to Cons' X and the rest of the array(index 1 to end) to Cons' tail,
// this tail then consists of a new Cons object with the new index 0(In the original Array index 1) is assigned to X and the
// rest is assigned to the tail, which again consists of a new Cons' object.
return(new Cons <TA>(a[0], Init(a.Skip(1).ToArray())));
}
//The f parameter is a function of type Func<TA, bool>. This allows for the caller to pass in the functionality
//that determines which items should be included in the result and which one should be excluded. In C# functions can return other functions.
//http://functionalprogrammingcsharp.com/higher-order-functions
public static List <TA> DropWhile(List <TA> l, Func <TA, bool> f)
{
// If the given list is empyty a empty Nil<TA> object is returned.
if (l is Nil <TA> )
{
return(Nil <TA> .GetNil());
}
var cons = (Cons <TA>)l;
if (f(cons.X))
{
return(DropWhile(cons.Tail, f));
}
return(l);
}
// A function that drops the all indexes up to index n for list l. The List l is already a nested object List/Cons.
public static List <TA> Drop(List <TA> l, int n)
{
// If the given list is empyty a empty Nil<TA> object is returned.
if (l is Nil <TA> )
{
return(Nil <TA> .GetNil());
}
// If the given index is less than or equal to 0 then the list is just returned as it was given.
if (n <= 0)
{
return(l);
}
// l is a nested cons object and that way we can drop the first index by only returning the tail.
// By then decrementing the element and calling Drop recursive we remove all indexes up to n.
var cons = (Cons <TA>)l;
return(Drop(cons.Tail, n - 1));
}
