El módulo F#Seq implementado en C#para IEnumerable?

Question

F # tiene un grupo de operadores de secuencia estándar que he llegado a conocer y amar desde mi experiencia con Mathematica. F # está recibiendo mucha atención ahora, y cuando está en lanzamiento general, tengo la intención de usarlo con frecuencia.

En este momento, dado que F # aún no está en su versión general, realmente no puedo usarlo en el código de producción. LINQ implementa algunos de estos operadores utilizando nombres similares a SQL (por ejemplo, ''select'' es ''map'' y ''where'' es ''filter''), pero no puedo encontrar la implementación de ''fold'', ''iter'' o ''partition''.

¿Alguien ha visto alguna implementación C # de operadores de secuencia estándar? ¿Es esto algo que alguien debería escribir?

Answer 1

iter existe como un método en la clase List que es ForEach

de lo contrario:

public static void iter<T>(this IEnumerable<T> source, Action<T> act)
{
foreach (var item in source)
{
act(item);
}
}

Answer 2

• fold = Aggregate

Dile a usar lo que hacen iter y partition , y podríamos completar los espacios en blanco. Supongo que iter = SelectMany y la partición podría implicar Skip / Take ?

(actualización) Busqué Partition - aquí hay una implementación cruda que hace algo de esto:

using System;
using System.Collections.Generic;
static class Program { // formatted for space
// usage
static void Main() {
int[] data = { 1, 2, 3, 4, 5, 6 };
var qry = data.Partition(2);
foreach (var grp in qry) {
Console.WriteLine("---");
foreach (var item in grp) {
Console.WriteLine(item);
}
}
}
static IEnumerable<IEnumerable<T>> Partition<T>(
this IEnumerable<T> source, int size) {
int count = 0;
T[] group = null; // use arrays as buffer
foreach (T item in source) {
if (group == null) group = new T[size];
group[count++] = item;
if (count == size) {
yield return group;
group = null;
count = 0;
}
}
if (count > 0) {
Array.Resize(ref group, count);
yield return group;
}
}
}

Answer 3

Si observa cuidadosamente, muchas operaciones Seq tienen un equivalente LINQ o pueden derivarse fácilmente. Solo mirando la lista ...

• Seq.append = Concat<TSource>(IEnumerable<TSource> second)

• Seq.concat = SelectMany<IEnumerable<TSource>, TResult>(s => s)

• Seq.distinct_by = GroupBy(keySelector).Select(g => g.First())

• Seq.exists = Any<TSource>(Func<TSource, bool> predicate)

• Seq.mapi = Select<TSource, TResult>(Func<TSource, Int32, TResult> selector)

• Seq.fold = Aggregate<TSource, TAccumulate>(TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)

List.partition se define así:

Divida la colección en dos colecciones, que contengan los elementos para los cuales el predicado dado devuelve true y false respectivamente

Que podemos implementar usando GroupBy y una matriz de dos elementos como tupla de un pobre:

public static IEnumerable<TSource>[] Partition<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
return source.GroupBy(predicate).OrderByDescending(g => g.Key).ToArray();
}

El elemento 0 contiene los valores verdaderos; 1 contiene los valores falsos. GroupBy es esencialmente partición en esteroides.

Y finalmente, Seq.iter y Seq.iteri trazan fácilmente foreach:

public static void Iter<TSource>(this IEnumerable<TSource> source, Action<TSource> action)
{
foreach (var item in source)
action(item);
}
public static void IterI<TSource>(this IEnumerable<TSource> source, Action<Int32, TSource> action)
{
int i = 0;
foreach (var item in source)
action(i++, item);
}

Answer 4

ToLookup probablemente sea una mejor coincidencia para List.partition:

IEnumerable<T> sequence = SomeSequence();
ILookup<bool, T> lookup = sequence.ToLookup(x => SomeCondition(x));
IEnumerable<T> trueValues = lookup[true];
IEnumerable<T> falseValues = lookup[false];

Answer 5

Aquí hay una actualización de la solución de partition de dahlbyk .

Devolvió una array[] donde "el elemento 0 contiene los valores verdaderos; 1 contiene los valores falsos" - pero esto no se cumple cuando todos los elementos coinciden o todos fallan el predicado, en cuyo caso usted tiene una matriz singleton y un mundo de dolor

public static Tuple<IEnumerable<T>, IEnumerable<T>> Partition<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
var partition = source.GroupBy(predicate);
IEnumerable<T> matches = partition.FirstOrDefault(g => g.Key) ?? Enumerable.Empty<T>();
IEnumerable<T> rejects = partition.FirstOrDefault(g => !g.Key) ?? Enumerable.Empty<T>();
return Tuple.Create(matches, rejects);
}

Answer 6

Rodar uno mismo en C # es un ejercicio interesante, aquí hay algunos de los míos. (Ver también aquí )

Tenga en cuenta que iter / foreach en un IEnumerable es un poco controvertido, creo que porque tiene que ''finalizar'' (o lo que sea la palabra) el IEnumerable para que realmente suceda algo.

 //mimic fsharp map function (it''s select in c#)
public static IEnumerable<TResult> Map<T, TResult>(this IEnumerable<T> input, Func<T, TResult> func)
{
foreach (T val in input)
yield return func(val);
}
//mimic fsharp mapi function (doens''t exist in C#, I think)
public static IEnumerable<TResult> MapI<T, TResult>(this IEnumerable<T> input, Func<int, T, TResult> func)
{
int i = 0;
foreach (T val in input)
{
yield return func(i, val);
i++;
}
}
//mimic fsharp fold function (it''s Aggregate in c#)
public static TResult Fold<T, TResult>(this IEnumerable<T> input, Func<T, TResult, TResult> func, TResult seed)
{
TResult ret = seed;
foreach (T val in input)
ret = func(val, ret);
return ret;
}
//mimic fsharp foldi function (doens''t exist in C#, I think)
public static TResult FoldI<T, TResult>(this IEnumerable<T> input, Func<int, T, TResult, TResult> func, TResult seed)
{
int i = 0;
TResult ret = seed;
foreach (T val in input)
{
ret = func(i, val, ret);
i++;
}
return ret;
}
//mimic fsharp iter function
public static void Iter<T>(this IEnumerable<T> input, Action<T> action)
{
input.ToList().ForEach(action);
}