Consider this code
let a, b, c = ...
let mutable l = [a]
if conditionB then l <- b :: l
if conditionC then l <- c :: l
I feel as this goes against the language principles. Is this the correct way or am I missing something?
Edit:
l is then just returned as a result
Sequence expressions (https://learn.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/sequences) are quite practical for this purpose.
[
if conditionC then yield c
if conditionB then yield b
yield a
]
It is difficult to say without seeing the code in a larger context - but given just this snippet, you can avoid using mutation by defining a new version of the list with a different name:
let a, b, c = ...
let l1 = [a]
let l2 = if conditionB then b :: l1 else l1
let l3 = if conditionC then c :: l2 else l2
Here, we first define l1 which contains just the element a. Then we define a new lists l2 and l3, which contain additional elements depending on whether conditionB or conditionC holds (if none of them hold, we just copy reference to the original list l1 two times).
F# also has a feature called variable shadowing which lets you reuse the same name and hide the original value, so you could actually reuse the same name l for your lists - the following means exactly the same as the above code:
let a, b, c = ...
let l = [a]
let l = if conditionB then b :: l else l
let l = if conditionC then c :: l else l
And you can drop the last let l = if you just want to return the final list as the result.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With