<p>I am writing a few extensions to mimic the map and reduce functions in Lisp.</p>

<pre><code>public delegate R ReduceFunction&lt;T,R&gt;(T t, R previous);
public delegate void TransformFunction&lt;T&gt;(T t, params object[] args);

public static R Reduce&lt;T,R&gt;(this List&lt;T&gt; list, ReduceFunction&lt;T,R&gt; r, R initial)
{
     var aggregate = initial;
     foreach(var t in list)
         aggregate = r(t,aggregate);

     return aggregate;
}
public static void Transform&lt;T&gt;(this List&lt;T&gt; list, TransformFunction&lt;T&gt; f, params object [] args)
{
    foreach(var t in list)
         f(t,args);
}
</code></pre>

<p>The transform function will cut down on cruft like:</p>

<pre><code>foreach(var t in list)
    if(conditions &amp;&amp; moreconditions)
        //do work etc
</code></pre>

<p>Does this make sense? Could it be better?</p>

I would use the built in Func delegates instead.  This same code would work on any IEnumerable.  Your code would turn into:
```
```
public static R Reduce<T,R>(this IEnumerable<T> list, Func<T,R> r, R initial)
{
     var aggregate = initial;
     foreach(var t in list)
         aggregate = r(t,aggregate);

     return aggregate;
}
public static void Transform<T>(this IEnumerable<T> list, Func<T> f)
{
    foreach(var t in list)
             f(t);
}
```
```