public synchronized Collection<Algorithm> getAlgos() {
		if (algos == null) {
			List<Algorithm> algorithmListBuilder = Lists.newLinkedList();

			for(ProductBundle bundle : algorithms.values()) {
				algorithmListBuilder.addAll(bundle.getAllAlgorithms());
			}
			algos = Collections.unmodifiableCollection(algorithmListBuilder);
		}
		return algos;
	}

int counter = 0;
stream
    .Aggregate(
        new Tuple<string, string>[],
        (seed, current) => counter++ % 2 == 0
            ? new[]{Tuple.Create(current, "")}.Concat(seed)
            : new[]{Tuple.Create(seed.First().Item1, current)}.Concat(seed.Skip(1))
    )
    .Select(double => new[] {double.Item1, double.Item2});

public IEnumerable<U> Map<T, U>(IEnumerable<T> target, Func<T,U> f)
{
    return target.Aggregate(new U[]{} as IEnumerable<U>, (seed, current) => seed.Concat(new U[]{f(current)}));
}

public IEnumerable<T> Where<T>(IEnumerable<T> target, Func<T,Bool> predicate)
{
    return target.Aggregate(new T[]{} as IEnumerable<T>, (seed, current) =>
        predicate(current)
            ? seed.Concat(new T[]{current}))
            : current
    );
}