indentation with composed and piped functions - f#

Question

I'm trying to get this block of code right, getting it readable by splitting into different lines, can use some help here.
list |> Array.iter ( fun data -> data.Href |> ( regex.Match >> ( fun m ->
let result = {ArticleModule.defaultArticle with publicationId = m.Groups.[1].Value; entityType = m.Groups.[3].Value; entityName = m.Groups.[4].Value; version = m.Groups.[5].Value}
) ) )
Edit
A shortest form perhaps to help further on how to break this in separate lines.
list |> Array.iter ( fun data -> data.Href |> ( regex.Match >> ( fun m -> Console.WriteLine m ) ) )
Attempt 1
list |> Array.iter (fun data -> (data.Href)
|> regex.Match // squiggly lines here
|> (fun m -> Console.WriteLine m))

Answer 1

First, since you ask how to indent this code, I'll point you to https://github.com/dungpa/fantomas/blob/master/docs/FormattingConventions.md, which is an excellent reference that you should probably bookmark. 3/4 of the way down that page you will find https://github.com/dungpa/fantomas/blob/master/docs/FormattingConventions.md#pipeline-operators which suggests that sequences of pipeline operators should be indented with the pipeline directly under the data that is flowing through the pipeline:
let result =
data
|> step1
|> Array.filter (fun x -> x == "something")
|> step3
And so on.
Now, to apply this advice to your situation.
First, the squiggly lines in your attempt 1 are because on the regex.Match line, you're still inside the fun data -> ... lambda. All lines in F# should line up vertically with the thing they belong to (vague language because this is a general rule that applies to many situations). Here, that would look like:
list |> Array.iter (fun data -> data.Href
|> regex.Match
|> (fun m -> Console.WriteLine m))
Now, that looks kind of ugly to me. So I would split out the fun data -> ... lambda into its own function:
let handleOneItem data =
data.Href
|> regex.Match
|> (fun m -> Console.WriteLine m)
list |> Array.iter handleOneItem
Much nicer.
Now, let's look at your original code, where the final lambda in the pipeline was not calling Console.WriteLine, but was creating a record. There's one error in that code, which is that a let statement does nothing in and of itself. What you probably wanted to write was:
fun m ->
let result = {ArticleModule.defaultArticle with publicationId = m.Groups.[1].Value; entityType = m.Groups.[3].Value; entityName = m.Groups.[4].Value; version = m.Groups.[5].Value}
result
Which in turn can simply be turned into:
fun m ->
{ArticleModule.defaultArticle with publicationId = m.Groups.[1].Value; entityType = m.Groups.[3].Value; entityName = m.Groups.[4].Value; version = m.Groups.[5].Value}
And now, I would recommend taking that long record and splitting it across multiple lines (see https://github.com/dungpa/fantomas/blob/master/docs/FormattingConventions.md#records for details), like so:
fun m ->
{ ArticleModule.defaultArticle with
publicationId = m.Groups.[1].Value
entityType = m.Groups.[3].Value
entityName = m.Groups.[4].Value
version = m.Groups.[5].Value }
I'd probably make this its own named function:
let mkRecord m =
{ ArticleModule.defaultArticle with
publicationId = m.Groups.[1].Value
entityType = m.Groups.[3].Value
entityName = m.Groups.[4].Value
version = m.Groups.[5].Value }
Now let's look again at the full code:
let mkRecord m =
{ ArticleModule.defaultArticle with
publicationId = m.Groups.[1].Value
entityType = m.Groups.[3].Value
entityName = m.Groups.[4].Value
version = m.Groups.[5].Value }
let handleOneItem data =
data.Href
|> regex.Match
|> mkRecord
list |> Array.iter handleOneItem
There's just one more mistake here, which is that Array.iter is the wrong type. Array.iter wants you to hand it a function that returns unit (i.e., returns nothing meaningful). Any function that returns nothing meaningful is clearly being called for its side effects, not its return value. Since mkRecord returns a value and has no side effects, you want Array.map instead. So the final version of your code would be:
let mkRecord m =
{ ArticleModule.defaultArticle with
publicationId = m.Groups.[1].Value
entityType = m.Groups.[3].Value
entityName = m.Groups.[4].Value
version = m.Groups.[5].Value }
let handleOneItem data =
data.Href
|> regex.Match
|> mkRecord
list |> Array.map handleOneItem

Answer 2

There is nothing wrong with using a for loop. If what you do in the end is an imperative operation like printing to the console, then using for loop clearly indicates that this is what you do:
for data in list do
let m = regex.Match data.Href
Console.WriteLine m
From your other example, it looks like you are trying to use Array.map to create a new array. The answer from #rmunn covers this nicely, but again, note that you do not need to do everything using |>. It is often easier to use let binding:
list |> Array.map (fun data ->
let m = regex.Match data.Href
{ ArticleModule.defaultArticle with
publicationId = m.Groups.[1].Value
entityType = m.Groups.[3].Value
entityName = m.Groups.[4].Value
version = m.Groups.[5].Value })