在C＃中递归遍历列表

Question

I am trying to learn functional programming fundamentals , How can I achieve the same result using C#, I know linq provides the Select Method for this kind of purposes , but I need to do this by myself to understand how to do recursion over lists .( I assume that Groovy redefines the + operator for lists ) .

/* sample in Groovy */

def <TResult> List<TResult> Filter(List<TResult> list, Closure cls)
{
    if(list.isEmpty()) {
        return []
    } else {
        return (cls(list.head()) ? [list.head()] : []) + Filter(list.tail(),cls)
    }
}

(Filter([1,2,3,4,5,6,7,8], { x-> x % 2 == 0 }))
.each( {teger -> println(teger) })

Answer 1

This makes no sense at all but is basically reprogrammed C# version of your code. Like I said this is no real world use of recursion in C# but maybe it helps you understand the language.

public static List<TResult> Filter<TResult>(List<TResult> input, Predicate<TResult> closure)
{
    if (input == null || input.Count == 0)
        return new List<TResult>();
    else
        return (closure(input.First()) ? new List<TResult> {input.First()} : new List<TResult>())
            // Replace '+'
            .Union(Filter(input.Skip(1).ToList(), closure)).ToList();
}

A more c# like design would be the following:

public static IEnumerable<TResult> RecursiveFilter<TResult>(IEnumerable<TResult> input, Predicate<TResult> closure)
{
    // Break on end
    if (input == null || !input.Any())
        yield break;

    // Keep going
    if (closure(input.First()))
        yield return current;

    // Recursive progression
    foreach (var filtered in RecursiveFilter(input.Skip(1), closure))
    {
        yield return filtered;
    }
}

Yield is syntactics sugar that creates the iterator pattern in the background. Simply put is is called everytime someone calls enumerator.MoveNext() on the enumerable. For more information please look at the MSDN reference . So in this examle it create a more functional approach to the recursion than simply creating new objects all the time.

Edit: Added alternative with yield.

Answer 2

Linq has equivalents to head and tail, which you can use with List<T>.

head - First() or FirstOrDefault()

tail - Skip(1)

Skip(1) has a similar effect to lazy evaluation, in that it returns an iterator to be executed later, rather than creating a new list now.