Concatenating lists of lists in F# - list

Question

From pseudo C#, I have this:
class C
{
List<A> a;
List<B> b;
}
List<C> L;
I would like to get to get two lists: ListA and ListB where ListA is the concatenation of all 'a' fields from the list L, and similar for ListB.
it would be something like:
var ListA = new List<A>();
var ListB = new List<B>();
foreach (var l in L)
{
ListA.Append(l.a);
ListB.Append(l.b);
}
In F#,
I assume it would be something like: let ListA = L |> List.Concat (but how do I say to pick the field a?)
or could it be done as a let ListA = L |> List.Fold (fun acc value -> acc.Concat value) (how do I specify the empty list here?)
or, can it be done like this?
let getElementsA (l : C list) =
seq {
for element in l do
for a in element.a do
yield a
}
but isn't that too verbose?

Answer 1

This is what List.collect, or Seq.collect for C# lists, is for:
let listA = l |> Seq.collect (fun element -> element.a) |> List.ofSeq
let listB = l |> Seq.collect (fun element -> element.b) |> List.ofSeq
Or if you really need to do it in one iteration you can use a fold:
let (seqA, seqB) =
l |> Seq.fold
(fun (seqA, seqB) element -> (Seq.append element.a seqA, Seq.append element.b seqB))
([], [])

Answer 2

You can use List.collect:
let getElementsA (cs : C list) = cs |> List.collect (fun c -> c.a)
if the property type is System.Collection.List<T> then you can use Seq.collect:
let getElementsA (cs : C list) = cs |> Seq.collect (fun c -> c.AS)
this returns a A seq which you can convert into a list using List.ofSeq:
let getElementsA (cs : C list) = cs |> Seq.collect (fun c -> c.AS) |> List.ofSeq

Answer 3

F# uses other lists, function objects (like delegates). You can find all that you need in Microsoft.FSharp namespace
If I have this code in F#.
A function that resives a list with action and return nothing (list:'a list -> action:('a -> unit) -> unit).
module FS =
let actLit list action =
list
|> List.iter (action)
For this on C#, include Microsoft.FSharp.Collections.ListModule module and call functions work with F# lists. ListModule.OfSeq(l) creates new F# list.
Microsoft.FSharp.Core.FunctionModule contains conversion methods.
After converting you can call it.
var a = new List<int> ();
var list = ListModule.OfSeq(a);
var func = FuncConvert.FromAction<int>(Console.WriteLine);
FS.actLit(list, func);