F#, trying to understand scope of expressions--should this work? [duplicate] - scope

Question

This question already has answers here:
Shadowing and Nested function
(2 answers)
Closed 6 years ago.
This is a highly skeletonized version of a financial algorithm. There's a lot more logic in the actual conditions and data processing represented here by "myFunc"--which isn't really intended to make sense in this version.
My question is: how do I understand why the use of firstMultiple in this block is permissible and sensible. Why should it work?
The expression is mapped directly from the line marked A to the line marked C3 where its value is used. But then at C1 and C2--which are (roughly) the same level of "indentation" as C3--here firstMultiple is assigned--seemingly as if it were mutable-??
I guess I don't understand why C3 uses firstMultiple while C1 can seemingly overwrite it. (The debugger, and running it, indicate that it's fine).
I'm hoping this question and example might elicit some insight into how to think about (nested) scopes. (I'm glad of course to have other comments on the design as well, but keep in mind that this code is extremely stripped of a lot of analysis.) (And I may have made the algorithm illogical in my stripping of it, but I'm trying to focus on the question of scope.)
let rec ListBuilder factor firstMultiple useFirstMultiple inputList outputList = // "A"
match inputList with
| [] -> []
| h::[] -> List.rev (inputList.Head :: outputList)
| _ ->
let nextInput = inputList.Head
let newOutputList, remInputList, firstMultiple = // "B"
match outputList with
| [] -> //first pass, capture firstMultiple now
let firstMultiple = nextInput * factor // "C1"
[nextInput], inputList.Tail, firstMultiple // "C2"
| _ ->
let lastOutput = outputList.Head
let multiple =
if useFirstMultiple then firstMultiple // "C3"
else lastOutput * factor
let newOutputList =
if (myfunc multiple nextInput: bool) then
nextInput :: outputList
else
outputList
let remInputList =
if not (myfunc multiple nextInput: bool) then
inputList.Tail
else
inputList
newOutputList, remInputList, firstMultiple
ListBuilder factor firstMultiple useFirstMultiple remInputList newOutputList

Answer 1

As this example is basically a loop of
let rec ListBuilder
...
ListBuilder
the loop hits C3 for every item in outputlist and then when outputlist is empty finally hits C1 and C2
At C3 firstMultiple is only read.
then firstMultiple // "C3"
At C1 and C2, firstMultiple is bound then read, notice I said bound not set or mutated
let firstMultiple = nextInput * factor // "C1"
[nextInput], inputList.Tail, firstMultiple // "C2"
At C1 firstMultiple is not the same variable as firstMultiple at A or B or C3, it is a new variable. So when you think that it is mutating the firstMultiple at the location of C3 it is not.
If your example conversion is correct then you could convert the code to this:
let temp = nextInput * factor // "C1"
[nextInput], inputList.Tail, temp // "C2"
or more simply
[nextInput], inputList.Tail, (nextInput * factor) // "C2"
In this example firstMultiple at C1 and C2 is just a reused variable name and because of shadowing is allowed, but not needed.
EDIT
The OP asked in a comment the further question:
why line "B" takes firstMultiple from "C2" and not from "A".
The reason is that line B is a tuple of three values which are generated by the result of the expressions following line B. All of this are the expressions that creates the three values for the tuple.
let newOutputList, remInputList, firstMultiple = // "B"
match outputList with
| [] -> //first pass, capture firstMultiple now
let firstMultiple = nextInput * factor // "C1"
[nextInput], inputList.Tail, firstMultiple // "C2"
| _ ->
let lastOutput = outputList.Head
let multiple =
if useFirstMultiple then firstMultiple // "C3"
else lastOutput * factor
let newOutputList =
if (myfunc multiple nextInput: bool) then
nextInput :: outputList
else
outputList
let remInputList =
if not (myfunc multiple nextInput: bool) then
inputList.Tail
else
inputList
newOutputList, remInputList, firstMultiple
The two lines that generate the three tuple values depending on the match result are
[nextInput], inputList.Tail, firstMultiple // "C2"
and
newOutputList, remInputList, firstMultiple
Line B is not a function with firstMultiple as a parameter, e.g.
let myFunc firstMultiple = ...
it is a match function that returns a tuple of three values
let newOutputList, remInputList, firstMultiple = // "B"
firstMultiple is not being passed in via B
but being created as a new variable and bound at C1
let firstMultiple = nextInput * factor // "C1"
and then returned via C2
[nextInput], inputList.Tail, firstMultiple // "C2"

Answer 2

Inner scopes can capture variables in outer scopes. I assume your question means that you were expecting an error when assigning a new value. There is a difference between shadowing and actual mutable variables. See these two examples.
Here the x is not actual mutable, though it feels like it:
let testValue (l: int list) =
let x = l.[0]
printfn "%A" x
do
let x= l.[1]
printfn "%A" x
printfn "%A" x
let x = l.[2]
printfn "%A" x
Here x is actually mutable:
let testValue2 (l: int list) =
let mutable x = l.[0]
printfn "%A" x
x <- l.[1]
printfn "%A" x
Try it with testValue [1;2;3]