Shadowing

[dukester]

It's my understanding that:

• values assigned to an identifier are immutable
• If an identifier is re-used, its "scope" is in a totally different context/environment.
• The original value persists.
  Is that correct?
  Is this what is referred to as "shadowing"?
  So then, is it possible to get rid of the second re-usage of an identifier?

[dukester]

For example:
val OneMile = 1.609;
val OneMile = 1609;
OneMile * 55;
val it = 88495

Now, if I'm done with the latter binding, how do I get rid of it so that I can use the former?

[JohnReppy]

Bindings in the REPL can be thought of as being part of a new let whose scope extends to the end of the interactive session. For your example, you have

let val OneMile = 1.609 in
let val OneMile = 1609 in
let val it = OneMile * 55 in
....

There is no way to revoke an existing binding. What you want is something that behaves like local (but the REPL does not provide that).

[dmacqueen]

In other words, the "scope" of a binding entered into the REPL is the rest of the interactive session, and is therefore in a sense unbounded. There is no need to cancel a declaration to "get back" a previous binding, since we can just bind it again!

val OneMile = 1.609; (* OneMile : real )
val OneMile = 1609; ( OneMile : int )
...
val OneMile = 1.609 ( OneMile : real = 1.609 again *)

There are an infinite number of possible variables, and they can be "rebound" over and over again, so there is no need to recover old bindings that have been shadowed.

If you want to use the same variable to name different things and have access to multiple meanings of the same variable, the module system allows you to do that.

structure A =
struct
  val OneMile = 1.609
end

structure B =
struct
  val OneMile = 1609
end

Now you can mention both A.OneMile (whose value is 1.609: real) and B.OneMile (whose value is 1609: int).

[dukester]

Got it! But I'll have to play with it to really, really get it! Thx ..

[dmacqueen]

In SML programming (and programming in general), there are situations where you want to use the same name for different things. One way of doing this is to "overload" an identifier, as we overload the "+" symbol to simultaneously denote Int.+ and Real.+ (addition for integers and for reals/floats). The actual meaning of an overloaded identifier is resolved by the type checker (e.g. in the context "x + 2", the overloaded "+" symbol resolves to Int.+ (and the variable x must therefore have type int). Overloading is intentionally very limited in SML; it is available for a small number of predefined variables like "+", and there is no facility for users to create new overloaded identifiers.

Another way of using the same identifier (variable) to denote different things is illustrated by my module example above, where the bodies of two different structures represent two non-overlapping scopes.

Another way to allow an identifier to have multiple meanings or values is to declare the same identifier in multiple scopes (as in the "let val x = 3 in let val x = 2 ..." example in my later message below. A good programming discipline is to not declare the same value in multiple overlapping (i.e. "nested") scopes. Instead, it is easy to use different (but perhaps "related") variables when they variable(s) will be used in the same scope, as in "let val x1 = 3 in let val x2 = 2 in ...". Very little extra mental effort is required to invent more variable names. (An anti-example is provided by code in a paper I read a while ago where all variables were named "x", except that two different stack variables were both named S. This made the code rather difficult to understand!)

[dukester]

Thx for the extra clarification! I think that my best bet is to use unique identifiers and reduce the complexity and possible confusion. I'll get the hang of soon enough I'm sure! Thx again ...

[dmacqueen]

Internally, the compiler resolves scopes of variables and associates occurrences of variables with the right binding of the variable, and then it generates unique internal variables for each source variable within its scope.

[dmacqueen]

(1) In SML, values in general are immutable, except for certain values that are mutable, for instance "ref" values for which there is an assignment operator.

• val x = 3;

x is "bound to" (i.e., names) the immutable integer value 3.

• val x = ref 3;

x is bound to a reference (or "ref cell") whose initial value is the integer 3. The type of x is "int ref". The value stored in the ref cell can be changed by the assignment operator ":=", as in

• x := 4;

The value of x is not changed -- it is still bound to the same ref cell, but the contents of that ref cell has been modified and is now 4.

(2,3) Yes, each variable binding has what is called a "static scope", which is the part of the program (expression, declaration) where that binding "applies" or is "visible".

- let val x = 3
= in let val x = 2
=     in print (Int.toString x)
=    end;
=    print (Int.toString x)
= end;

will print the two integers 2 and 3. The "inner" binding of x (to 2) applies to the first call of print while the "outer" binding of x (to 3) applies to the second call of print. The second declaration of x "shadows" the first declaration of x in its scope, which is the (first) expression "print (Int.toString x)". When you ask for the value of x, you will get the value bound to x by the innermost declaration.

[dukester]

So the "in ... end; is the block I was asking about above?

[dmacqueen]

At the most basic level, there are expressions and declarations. Expressions express values (or evaluate to values). Declarations declare, or bind, names (variables) to values.

let <declaration> in <body expression> end

is a compound form of expression whose value is that of the body expression, which is the scope of the declaration. Thus

let val x = 3 in x + 1 end

is an expression that evaluates to 4.

Meta: there are a lot of concepts and terms involved in learning Standard ML, and the most efficient approach to covering them is to read a good book or tutorial on the language. Some books and tutorials are mentioned on the web page smlnj.org, but they may not be at the right level for your purposes. One book I have recommended is "ML for the Working Programmer" by Larry Paulson. It is available on-line as a set of PDF files at https://www.cl.cam.ac.uk/~lp15/MLbook/pub-details.html. Could you take a look at that and let us know if it is helpful?

[dmacqueen]

Another more elementary, and more fun tutorial on SML is "The Little MLer" by Felleisen and Friedman (MIT Press, 1998). Unfortunately it appears to be out of print, according to Amazon.com. https://mitpress.mit.edu/9780262561143/the-little-mler/.

[dukester]

I have Larry Paulson's book. Thanks for the recommendation. The-Little-MLer would be the one to though, IMHO and from the reviews I've read. I'm also listening to https://www.youtube.com/playlist?list=PLSQSd2QKLgQrKinrHHyDwzngrXyULFm25.

[dmacqueen]

A comment on the terminology.

Carrying over ideas from other languages, it is common for SML beginners to think of a declaration like

val x = 3

as an "assignment" of a value to a "variable" x, where it is implicitly assumed that "x" designates a location in memory, and the declaration is storing the value 3 at that location.
This is not the right way to think of variables in a functional language (or in the lambda calculus that implicitly underlies functional languages). In functional languages, variables are treated in a way that is similar to the variables are treated in mathematics, say in calculus. When we write an equation like

x^2/dx = 2x

the variable "x" stands for some arbitrary, unspecified number. This is similar to the use of variables when specifying a function

\x.x+1   (where "\" should be read as "lambda"; "fn x => x+1" in ML notation)

Here x represents an arbitrary argument value to which the function could be applied. When the function is applied to a particular value, as in

(\x.x+1) 2

then x is "bound" to 2 (or becomes a name for 2) and the "body" of the function, x+1 is evaluated to return the value 3. This function application can be (approximately) translated to the expression

let x = 2 in x+1 end

In summary, using the term "assignment" when talking about a variable declaration in a language like ML has the wrong connotation.

[dukester]

Thanks for explaining and clarifying the difference between "binding" and "assigning". I never got too far with scheme because I had so much "time in" with using "assignments" which has been my norm since 1982 when I was hacking Z-80 assembler code on my dual-CPU Apple-][e Taiwanese clone box. I'll have to un-learn, or at least re-focus on that score.

[dmacqueen]

Learning any new programming language seems to involve a lot of "unlearning" of things that one has internalized from experiences using previous languages. A long time ago I had a summer job programming in PL/I, which I initially treated as a funny dialect of Fortran.

[dmacqueen]

And thanks for the link to the videos by Dan Grossman. He was a summer intern with us many years ago when he was a graduate student.

[dukester]

Dan Grossman got a swell start then! BTW, I passed the word on Libera IRC #sml channel that this github site exists and is open for business. I hope some stop in for a visit.

[dmacqueen]

Thanks for mentioning this on the IRC #sml channel.

We are going to be using both this Discussion channel (for GitHub.com/smlnj) and the
standardml.zulipchat.com streams under the Zulip "Standard ML" organization for answering questions and announcing things like new Releases of SML/NJ.