On 5/7/2020 2:07 PM, kipplebits wrote:

You can't.

In general, once you've set the value of a "variable", you can't change
it.  They're really more constants than variables.  The picture is a bit
more complicated than that - for instance, you can set a new value
inside some kinds of blocks - but that's the way to think about it.

In particular, what you're trying to do is sort of equivalent to this:

x = 0;
for (i = [1:10]) {
x = x + 1;
echo("looping", x);
}
echo("done", x);

... which produces this output:

ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "looping", 1
ECHO: "done", 0

because the "x=x+1" takes the x that was defined outside the loop, adds
one to it, and puts the result (always one) into an x that is for that
iteration of the loop.

And then after the loop, you're seeing the outside-the-loop x again.

...Right, Thank! ...I think I was actually already doing this
subconsciously, although I guess I was working a little outside of my
comfort zone, and got turned around. ...Also probably didn't help that I
was using a 3 year old build.(up to date now!) ...i guess the problem in my
example was related to scope then; I think in most programing
languages(c++, java) a for loop carries the same scope as it's
surroundings... ...also vectors/arrays are not static... ...kind of a
curveball ;P

OpenSCAD is sort of strange if you are used to c++ or java. how would you
classify OpenSCAD as a programing language? what other language would you
say it is most like?
https://en.wikipedia.org/wiki/List_of_programming_languages_by_type#Pure
...Haskell?

Anyway I think I'm straightened out now, Thanks! hopefully I won't decide
to import code snips into my scad files again.

On Thu, May 7, 2020 at 6:46 PM Torsten Paul Torsten.Paul@gmx.de wrote:

I would place OpenSCAD solidly in the functional camp.

t helps to understand that OpenSCAD is actually a fairly thin layer over
OpenCSG; if you take a look at some "compiled" code using Design -> Display
CSG Tree, you'll see that OpenSCAD's output is a static structure in an
"assembly language" not too different from OpenSCAD itself. OpenCSG doesn't
have any concept of variables or of mutating state. Those quirks propagate
up the stack into OpenSCAD.

It can take a big adjustment to learn to think in OpenSCAD, but I've found
that programming in this environment forces me to have a discipline that's
made me a better programmer in other languages.

Best of luck!

On Fri, May 8, 2020 at 1:04 AM kipple bits kipplebits@gmail.com wrote:

Another way to think of it is that OpenSCAD script is not a program, it is
a description of some geometric objects. When you describe
something static nothing about it changes during the description, so no
variables are needed.

It is also like maths in that x = x +1 does not make sense.

On Fri, 8 May 2020 at 11:21, Max Bond max.o.bond@gmail.com wrote:

I think that sums up the OpenSCAD variable dilemma.
"It is also like maths in that x = x +1 does not make sense."
as a static equation, as NopHead says it does make sense mathematically, I agree.

But to see it as a powerful programming concept of a calculation followed by an assignment means it is a very, very sad omission in OpenSCAD.

My limited understanding of OpenSCAD is that it was thrown together to generate  .stl files to make 3-D printer parts. This maybe mythological garbage I have accumulated from somewhere, or maybe true. If that is true, it has succeeded in that sense and in many other fantastic designs.

I have found OpenSCAD immensely useful and inspiring in its current incarnation. I am indebted to its authors. But it seems to me that the long term users of it have so much code they don't want to see broken, and they are the ones most qualified to change it, that nothing is going to change soon.

Call OpenSCAD whatever type of programming you like, if it is unable to implement a simple accumulator increment, then it simply appears a mysterious orphan,  cast off from the very architecture that actually makes it possible. Very curious.

If it is possible to set up increments/assignments in For loops, why not for other variables?

Rob

On 8 May 2020 8:31:38 pm AEST, nop head nop.head@gmail.com wrote:

On 5/8/2020 4:58 AM, Rob Ward wrote:

First, I have to note that I know nothing of the internals of OpenSCAD. 
However, I have done some black-box exploration of its behavior.

There are two distinct questions there:

• Could there be a language similar to OpenSCAD that has more
  "conventional" behavior?
• How hard would it be to change OpenSCAD to behave like such a language?

I think the answer to the first is clearly "yes".  One can readily
imagine languages that behave more conventionally.  Most likely, one
would just build a CSG library for some existing language like Python or
JavaScript.

The answer to the second question is much trickier.  Again, I'm not
familiar with the internals of OpenSCAD, but black-box testing shows
that its behavior is even further from "conventional" than it first appears.

Consider:

x = echo("1") 0;
echo("2");
y = echo("3") 0;

Simple enough, right?

ECHO: "1"

ECHO: "3"

ECHO: "2"

Or the behavior of children():

module x() {
    children(0);
    children(0);
    children(2);
}

x() {
    echo("0");
    echo("1");
    echo("2");
}

It's not terribly unobvious, but doesn't bear much resemblance to a
conventional language:

ECHO: "0"
ECHO: "0"
ECHO: "2"

Speaking of children, how do assignments and children interact?

module x() {
    a = echo("a") 0;
    children(0);
    b = echo("b") 0;
}

x() {
    c = echo("c") 0;
    echo("0");
    echo("1");
    echo("2");
    d = echo("d") 0;
}

Did you expect this?

ECHO: "c"
ECHO: "d"
ECHO: "a"
ECHO: "b"
ECHO: "0"

Net, the execution flow in OpenSCAD doesn't look much like what you
would expect from a conventional language.  Could a language have the
same goals and be more conventional?  Sure.  But it's clear that the
internal plumbing of OpenSCAD is very, very different from a
conventional language and it would require a substantial overhaul to
become more conventional.

And I suppose there's a third question:

• Could OpenSCAD be changed to be more conventional, while retaining
  compatibility with its current behavior?

Technically, no.  One can readily write OpenSCAD programs that would
execute differently in a more conventional language.

One such case is the fact that assignments are processed before module
invocations:

echo(x);
x = 1;

Another is the fact that assigning a value inside a scope creates a new
symbol visible only inside that scope:

x = 1;
if (1 == 1) {
    x = 2;
    echo(x);
}
echo(x);

yields

ECHO: 2
ECHO: 1

And the fact that when you define an OpenSCAD symbol, the value of the
same-named symbol from the enclosing scope is still visible:

x = 1;
for (i = [0:1]) {
    x = x + 1;
    echo(x);
}

yields:

ECHO: 2
ECHO: 2

Do people actually use these ... interesting ... cases?  I don't know. 
But they clearly could, and so true compatibility would not be possible.

Somebody asked how to classify OpenSCAD.  My personal model is largely
that it is a macro processing language, that executing an OpenSCAD
program consists of expanding the various macros to form the resulting tree.

One thing that I do wonder is how isolated the language processing is,
inside OpenSCAD.  Hypothetically, it seems like the language processing
could be a black box that takes source text as input and returns a
geometry tree as output.  If it is such a black box, then perhaps it
would be practical to make it a plug-in, so that one could type Python
into the editor, with an appropriate Python library, and have the
results end up in the viewing window.  One could even imagine
cross-language calls that passed parameters and returned geometry.

Let me be clear:  that's just a fantasy.  I'm not asking the developers
to work on such a thing.

On 2020-05-08 20:00, Jordan Brown wrote:

Yes, AngelCAD is like that, using AngelScript.
https://arnholm.github.io/angelcad-docs/

Carsten Arnholm