On Sat, Aug 6, 2016 at 4:08 AM, T L <tapir....@gmail.com> wrote:
>
> If you carelessly change the value of a global variable in std lib, some
> hard found bugs will be created.
This is what you really want, and it is the reason I was talking about
immutable variables earlier.
In Go, a constant is created at compile time and always has that
value. You started this thread talking about the io.EOF variable.
The io.EOF variable is initialized with a function call. It is
written in the source code in io/io.go as
var EOF = errors.New("EOF")
In Go, it does not make sense to speak about a constant that is
initialized from a function call. Constants are set at compile time,
so when would that function call run?
If you look at the implementation of errors.New, you will see that it
returns a pointer. So even if you somehow decide that the result of
errors.New is a constant, what you have is a constant pointer. That
says nothing about the value to which the pointer points. Even if you
described the pointer as a Go const, the value to which the pointer
points could still be changed, so the overall meaning of the value can
change. So it's not enough to speak about a constant value. You have
to speak about a constant value that points to another constant value.
Of course, you can't take the address of a constant in Go--if you
could, you could change its value. So once again we are back to
talking about immutability.
It's easy to say the words "constant interface value." In the context
of a programming language, you need to think about what those words
really mean and how they would be implemented.
Ian
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
