lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index]

On Mon, Jul 15, 2019 at 11:55 AM nobody wrote:
But these two things in combination create a problem:

> The statement works for all names independently of what a name is:
> local/upvalue/global.

> The white-list must contain only visible names, otherwise
> compilation error is raised.

What about to-be-defined "globals"?  (Will you have to "pre-declare" them?)

I'm aware of two ways to turn on strict control over globals usage at compile-time:
1) separate the globals' namespace from the other namespaces (for example, by using prefix "$" or "_ENV.")
2) explicitly declare (white-list) globals you want to use in your code

This suggestion implements both these approaches:

1) You can separate namespaces (by using prefix "_ENV.")
   with _ENV do
      _ENV.non_existing_global = 42

2) You can white-list all the globals you need
   with print, math, non_existing_global do
      non_existing_global = 42

3) You can combine these two approaches:
most frequently used globals are white-listed, others are prefixed
   with print, _ENV do
      _ENV.non_existing_global = 42

It's your own decision: to pre-declare to-be-defined globals or to use "_ENV." prefix for them.

And what about this?

   Point2D.length =
     function( _ENV )  with x, y do  return (x^2+y^2)^0.5  end  end

(which could (more or less) equivalently be written as

   function Point2D:length( )  return (self.x^2+self.y^2)^0.5  end

but is shorter / more readable this way and already (without with)
gives the guarantee that you'd at most pollute the object you're
working on, not the outer environment.)

Nice example!
Yes, it would be more readable in "Point2D:length()" to use "self" instead of "with".
This example shows that for some (but not all) situations Lua already has a trick to write a "pure function".
But "with" statement gives more universal control over visibility of variables, and it also protects against typos.
If the price of an error is quite high and the inner block is much longer than "(x^2+y^2)^0.5" then you would probably prefer to use "with".

     local print = print
     local _ENV = { x = 23 }
     function )  with print, x do  print( x )  end  end
     -- up to this point you cannot even tell that _ENV might change
     -- again (so this would break Lua's single-pass compilation)
     function newenv )  _ENV = newenv  end
     -- only now it's clear that _ENV might be changed
   bar { y = 5 }
   foo ()

Because _ENV can change dynamically, you cannot determine at compile
time what names will be valid, so you cannot always raise a compile time

What does "valid" mean?
Only visibility does matter.
The "with" statement doesn't care about whether a variable contains nil or non-nil value.
Absolutely all globals (including non-existing) are considered visible outside of the most outer "with" statement.

>     Variant #1
>        local function pure_func(x, y)
>           with x, y do   
>              -- all upvalues and globals are inaccessible here
>              ...
>           end
>        end

you have to write all arguments twice…

Yes, that's significant inconvenience.
See "suggestion #2" below to find how it could be fixed.

I'd prefer that to work like

   local x, y, z with a, b, c do
     … (both x,y,z AND a,b,c are visible here) …

OK, I see your point: it would avoid typing variable names twice as in the following code:
   local x, y, z
   with a, b, c, x, y, z do
      -- both x,y,z AND a,b,c are visible here

OK, let's try to avoid this unneeded typing.

Suggestion #2, improved:

Let "with" be not a statement, but an optional prefix for arbitrary Lua statement.
   with white-list-names inner-statement

If inner statement is "do...end" then we are getting our previous form
   with x, y

If inner statement is a local variables definition then we are getting exactly what "nobody" wants (don't typing local variables twice):
   with x, y
      local sum, diff = x+y, x-y
   -- variables "sum" and "diff" are accessible outside "with"
   print(sum, diff)

If inner statement is a local function definition then we are getting compact code to define a "pure function" (don't typing function parameters twice):
   with math
      local function pure_func(x)
         return math.sin(x)/x
   -- local variable "pure_func" is accessible outside "with"

Inner statement could be just anything:
   with x
      return x, x+1, x+2

   with a, i, j
      i, j, a[i], a[j] = a[i]~a[j], j+1&255, a[j], a[i]

Linebreaks in these examples are just for readability, spaces could be used instead.

It's impossible to use empty white-list because of the following ambiguity:
   with a (b or c)[1] = 42
Is it
      a(b or c)[1] = 42
   with a
      (b or c)[1] = 42

An underscore (or could be used instead of empty white-list (but only for most outer "with").
   with _

   with _
      local function f(n)
         return n*(n+1)/2

   with _
      local t = {
         pure_func1 = function(x) return (x+1)/(x-1) end,
         pure_func2 = function(x, y) return x*y+x+y end,

Please note the difference between defining a new local and defining a new global:
   with x
      local new_var = x*x     -- new local

   with x, new_var
      new_var = x*x           -- new global

This is because the local variable is actually being created by the statement,
but globals are considered already created (just like already existing local variable).
   local old_var
   with x, old_var
      old_var = x*x           -- old local