As I understand it, let() allows you to define intermediate constants that
you can use later in the function.

Suppose you had a function that used sin(x) multiple times:

function myCalculation( x, y ) = sin(x) + 2 * sin(x) + 10 * y * sin(x);

It's easier (and maybe more efficient) to only calculate the sin() once:

function myCalculation( x, y ) =
sin(x) + 2 * sin(x) + 10 * y * sin(x);

On Fri, Dec 23, 2022 at 2:31 PM Father Horton fatherhorton@gmail.com
wrote:

Leonard Martin Struttmann
3:27 PM (0 minutes ago)
Reply
to OpenSCAD
As I understand it, let() allows you to define intermediate constants that
you can use later in the function.

Suppose you had a function that used sin(x) multiple times:

function myCalculation( x, y ) = sin(x) + 2 * sin(x) + 10 * y * sin(x);

It's easier (and maybe more efficient) to only calculate the sin() once:

function myCalculation( x, y ) =
let ( sinx = sin(x) )
sinx + 2 * sinx + 10 * y * sinx;

On Fri, Dec 23, 2022 at 3:27 PM Leonard Martin Struttmann <
lenstruttmann@gmail.com> wrote:

I understand what it does; it just seems an outlier to me in OpenSCAD
syntax.

On Fri, Dec 23, 2022 at 3:28 PM Leonard Martin Struttmann <
lenstruttmann@gmail.com> wrote:

On 12/23/2022 12:27 PM, Father Horton wrote:

Technically, it's part of the syntax of expressions.  You can use it,
echo, and assert in front of any expression (including buried inside an
expression).

Practically, it's part of a micro-language usable in expression
contexts, where the full language isn't available.

I don't like it, because it means that non-trivial functions are written
in a different language than modules are written in.

Yeah, it is obnoxious that functions and modules have a different syntax.
If you want to convert code between function and module you have to change
it.

If you want a way of seeing let() as fitting in with openscad syntax, you
can interpret let() as similar to a module with a child.

On Fri, Dec 23, 2022 at 4:53 PM Jordan Brown openscad@jordan.maileater.net
wrote:

I checked the "make OpenSCAD normal" thread on github. Multiline functions
came up with several responses along the lines of "Well, you can do it with
let." That's true, but (as Adrian notes) "obnoxious." I'm not a C/C++ guy,
but I at least vote that if someone wanted to do it, I'd be happy.

On Fri, Dec 23, 2022 at 4:56 PM Adrian Mariano avm4@cornell.edu wrote:

On 12/23/2022 3:16 PM, Father Horton wrote:

Could we come up with a syntax for functions that allowed standard
OpenSCAD syntax, perhaps with a new "return()" statement?

Note that if() and for() would have only limited value, because of the
inability to get any data out of them.

For the basic "function" declaration syntax, we could have

function f(args) { ... body ... return(val); }

because standard "function" requires an "=".

For function literals we couldn't do that, or rather it would collide
with planned object syntax:

f = function (args) { ... body ... };

would collide with a current-syntax function literal that returns an
object.  (Objects are not nailed down yet, but it's very likely that {
something } is going to be an object.

I would never claim that it's pretty, but I have an experimental where
this kind of incidentally already works:

function f(x) = {( y = x*2; return = y+1; )}.return;
echo(f(2));

{(...)} is temporary syntax for a "hybrid" object literal, using a
definition where the object literal is arbitrary OpenSCAD-language, with
the elements of the object derived from the assignments and any geometry
created is brought along as an invisible part of the object that can be
added to the model later.  What I've said above has the function create
an object with members "y" and "return", and then return only the value
of the "return" member.

It's temporary syntax because that experimental also supports
JavaScript-style { a: 1, b: "hello" } object literals, and {{ ...
arbitrary OpenSCAD ...}} geometry literals that yield a geometry value. 
I wanted to have both variations available to play with.  If we go with
the "hybrid" style, I'll switch it over to being { ... arbitrary
OpenSCAD ... }.