So what I'm basically saying is that if you want help, it's usually better to start with "please", rather than threatening legal action.

That is true. It wasn't a threatening... And this is a great site. But I made the same request, back in 2010, and I was adviced to make a Microsoft Connect issue. I did, and didn't get response. Now if I try to go to the Connect-page with that Id I see that it is removed or something: The system has encountered an unexpected error.

But... a year ago I watched a few great videos. I don't know which was them, and videos are not easy to search. I would like to see them again and recommend to a friend. I gave them 5 star rating. So I would like to have "my rated videos" in profile (or a second queue).

I think this is a fair request:

1) You must have info about them because I can't vote many times the same video

2) By EU law, I have the right to get the information you store about me. 

Matthew's Concat uses recursive aggregate and function as accumulator value.

• To replace Bind we need many aggregates... (or do we, maybe not?)
• By default, Aggregate/fold will exit the monad (so we "reify" (=execute), get the side effects and break the continuation)
• By using func here, we can remain the continuation.
• But still we kind of exit and enter the monad many times, which could affect the performance.

Bind is not totally "pure" as outer function will produce set of results but the outer function doesn't actually know (by type syntax) how to combine different results produced by the inner function. So it has to know something about these results that the function syntax won't tell us.

In theory Bind could match without running through items. Then it would be different. See this short video. Maybe do the concatenation without creating a new instance... (or with immutable data structures this means just using the pointer to old when creating a "new" one). This way we could get e.g. effective parallel execution. I think the current implementations, when they flatten, can reuse items but not the inner collections (/monads).

void Main(){   var l = new[]{new []{1,2,3},new []{4,5,6}};   var res1 = l.SelectMany(s => s.Select(i => i+1));   res1.Dump();      var res2 = l.MySelectMany(s => s.Select(i => i+1));   res2.Dump();}public static class myExtensions{   public static IEnumerable<TResult> MySelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector){      return source.Aggregate(Enumerable.Empty<TResult>(), (a, s) => a.Concat(selector(s)));   }}

3 hours ago, JohnAskew wrote

This article is by Bart De Smet and is worth a look: http://dotnet.dzone.com/news/linq-folding-left-right-and-th

Here's another nice article about folds in LINQ: http://weblogs.asp.net/podwysocki/archive/2009/02/26/functional-c-fun-with-folds.aspx

Thanks for the links... Matthew there wrote how to make .Concat() with .Aggregate(), so that is ok to use I guess...

Videos like this state that "Bind is the mother of all operators". But is that true, if you can do bind with Aggregate (=fold)?

I'm not looking to make a specific task, I just want to make this clear to me.

The "predicate(s)" is just anything that holds the definition of the Where predicate:

 Func<TSource, bool> predicate

The "selector(s)" is just anything that holds the definition of the SelectMany selector:

Func<TSource, IEnumerable<TResult>> selector

The concrete implementation doesn't matter.

---

Fold / Aggregate is a kind of visitor pattern to visit every item of the container (monad).

---

The SelectMany (monadic bind) syntax is something like this:

M<A> -> (A -> M<B>) -> M<B>

LINQ deals with immutable collections. So M<A> is not altered/transformed. Instead someone will know how to create a new M<B>. And applying this (A->M<B>) will mean that there must be a way to get A from M<A>. That will need some kind of visitor pattern. 

This post refers to some Going Deep videos...

Greg told in his video about shape, wrap and roll.

LINQ Select many is "wrap" and Aggregate is "roll", right?

LINQ Where have this kind of signature:

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 

So... As Bart said in his video, "where" could be done with SelectMany.

• public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);

I'll try...It will be something like this:

return source.SelectMany(s => Enumerable.Repeat(s, predicate(s) ? 1 : 0));

But.... as Ralf said in his video, "where" could be done with Aggregate.

• public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func);

I'll try...It will be something like this:

return source.Aggregate((a, s) => predicate(s) ? a.Concat(Enumerable.Repeat(s, 1)):a);

Now... Can we do Aggregate with SelectMany?

No? Can you prove it?

It shouldn't be possible, as monads are about shap, wrap (=bind, here: SelectMany) and roll (here: Aggregate)?

SelectMany seems to be easy to do with Aggregate:

return source.Aggregate((a, s) => a.Concat(selector(s)));

Am I cheating here by using Concat? That will aggregate again inside the same container(monad). Will it use SelectMany inside?

I could do SelectMany with Aggregate by exiting the monad and go back again (so I will cause the side effect to exit the monad and break the continuation), right? So:

// SelectMany:
M<A> -> (A -> M<B>) -> M<B>

// Aggregate:
M<A> -> B -> (B -> A -> B) -> B
// Aggregate (if accumulator would be type of M<B>):
M<A> -> M<B> -> (M<B> -> A -> M<B>) -> M<B>
// this Aggregate without initial value:
M<A> -> (M<B> -> A -> M<B>) -> M<B>
// This is very near to select many, you can handle the extra parameter in the inner func as you like...

So I can use IEnumerable<T> as accumulator (or could even a Func<...>). On the other hand, LINQ-methods are not pure... e.g. SelectMany is not pure monadic bind: it has some overloads.

Here they are:

https://connect.microsoft.com/site1133/feedback/details/607324/i-would-like-to-see-the-list-of-ratings-i-have-given

https://connect.microsoft.com/site1133/feedback/details/607330/want-to-see-it-button

Hi!

I remember watching and rating a video. I would like to recommend it to a friend. But I don't remember what video it was...

I would like to see the list of ratings I have given.