How do you flatten a set while keeping the parent object?

Question

In C# you would just use SelectMany which has an overload for holding onto the parent object. How do you do the same thing in F#? That is, I want to iterate over a set of assemblies and return all of those assemblies that have classes implementing a specific attribute.

I know I collect is similar to select many, but I'm not sure how to use it while maintaining the parent (assembly) information.

It sounds like you just want to _filter_ the list of assemblies. Is that right? — Daniel, Mar 19 '13 at 16:52
Essentially right, but how do I filter without having a huge nested mess? That's what I'm trying to do. — sircodesalot, Mar 19 '13 at 18:38
Related: http://stackoverflow.com/questions/4599657/f-list-selectmany/4600047 — gradbot, Mar 19 '13 at 20:06

score 1 · Answer 1 · answered Mar 19 '13 at 17:01

1

It looks like you just need filter instead of collect:

let hasTypeWithAttribute<'t when 't :> Attribute> (a: Assembly) = a.GetTypes() |> Array.exists (fun t -> t.GetCustomAttributes(typeof<'t>, true).Length > 0)

let assemblies = inputSet |> Set.filter hasTypeWithAttribute<AttributeName>

answered Mar 19 '13 at 17:01

Lee

142,018
20
234
287

Seriously, I spent all entirely too much time on this for such a simple answer. Heh, thanks a lot! – sircodesalot Mar 19 '13 at 18:40

score 1 · Accepted Answer · answered Mar 19 '13 at 17:21

You can implement SelectMany using collect by applying a map to the collection of "children" that you want to return for each element of the "parent" collection:

Assuming you have some source and want to get children using getChildren (for each element in source) and then you want to calculate the result using selectResult that takes both child and parent, you can write the following using SelectMany:

source.SelectMany
  ( (fun parent -> getChildren parent),
    (fun parent child -> selectResult parent child ) )

Using collect, the same code looks as follows (note that the map operation is applied inside the lambda function that we're passing to collect - where parent is still in scope):

source |> Seq.collect (fun parent ->
  getChildren parent 
  |> Seq.map (fun child ->
      selectResult parent child ))

It is also worth noting that the behavior captured by SelectMany can be implemented - perhaps in a more readable way - using F# sequence expressions like this:

seq { for parent in source do 
        for child in getChildren parent do
          yield selectResult parent child }

Awesome, a lot of useful information to learn from here. Thanks again! — sircodesalot, Mar 19 '13 at 18:41

How do you flatten a set while keeping the parent object?

2 Answers2