atoms equivalent to tuple singletons

7.7: adda/syntax/atoms equivalent to tuple singletons:
. does a function's arg need a parenthetical?
ie, can we say( f x ), instead of( f(x) )?
if (f x) can be the same as f(x),
then all atoms (such as x)
can be seen as singleton tuples (ie, x=(x) );
so, then there's no need for adda to copy
Python's singleton tuple syntax: ( (x,) ).

[8.8:
. I think Python's view is that
a tuple is a distinct datatype
that must have a distinct literal;
and, while Python could have assumed that
all atomics were singleton tuples,
that would have been rather wasteful;
because, in an oop system like Python,
where everything is type-tagged,
a singleton tuple would take up more space
than the atom it contains .
. adda's view is that explicit syntax
is not as helpful as simpler, cleaner, freer;
and since all objects have a declared datatype;
we'll know if something needs a tuple,
and can tuple-ize an atom as needed .
8.9:
. Python also has a situation like math
where ( f NotAParenthetical ) is reserved
as a pointer to function
and only ( f(x) ) is applying f to x .
. in Python you don't have to
declare f to be a function;
(eg, you can say:
if truth: f = lambda(...) else: f = 0
-- here f wasn't declared to be anything;
rather its type depends on
what value it's assigned);
so, it's important in Python
that the function application syntax be
unambiguous and very easy to spot .
. in adda, by contrast,
we can assume that functions are declared
(they are statically always functions);
so, if we expect f to be followed by
the arg it's being applied to,
and if we want to pass f without applying it,
we follow it with a syntactic terminal;
eg,( (f) ), or (f, ...) or (... f; ...) .]
mis:
. we can assume that binary operators (biops)
are declared to be biops before use;
. so, if x is not a biop,
then the expression ( x y )
has to mean either x*y or x(y)
or the syntax is invalid;
( x*y = x y ) can be true only if
x or y are numbers and not functions,
or x is a number while y is a dimension;
if none of that is true,
we can assume (x y) to mean x(y) .
--[8.8:
. in that paragraph,
I'm playing with the idea that
non-biop functions need not be declared;
but that would imply the confusing use of
completely optional parameters .
8.9:
. furthermore, that paragraph was
glossing over the complication that
all biops can be used in prefix mode:
f +(a,b,c) = f (a + b + c);
so, knowing what's a biop in a given context,
requires some look-ahead .]