2009-12-27

control.struct's

8.28: adda/syntax/subroutines:
. should there be syntax to make it clear
that a subroutine is a local symbol?
. should the syntax be the same as for record members ?
. from the object view,
program instantiations are activation records,
and subprogram instantians are extensions
(components) of that act'rec .
[8.29:
. it had prev'ly been decided that algorithm internals
could be accessed with record field notation .
. the question now is how internals can refer to themselves:
it would be useful during collisions among imported names .
. the explicit names could borrow from unix:
just as [./] is the current file directory,
[.`] would be the current activation record,
and [..`] would be the enclosing activation record
(ie, the subroutine's parent scope) .
] .

9.2: adda/syntax/algorithms recur:
. "(self) as a reference to recursion may not be the best choice .
. what about when a type wants a pronoun for its own type?
self might be a good term for that .
. and to use self to refer to algorithms might strike some as not object-oriented,
[9.2: or not even very accurate:
when you do a task, is your task self? no:
the self is either a type`mgt, or a processor .
. instead of "(self) for recursion, use recur .

9.6: adda/syntax/if:
. if b: s;
if ( b: s -- then
, b: s -- elsif/then
, s -- else .
);
. this for those who don't want to use
b ? s;
no? b? s;
no? s .
. nor want to use:
b? (yes: s
, no: b? (yes: s
, no: s
)) .


9.6: adda/type"to/goto`tag`decl':
. there needs to be a way to distinguish between
various uses of colon: (goto tags, case stmt's)
. the goto tag is declaring a new symbol
that names the address of the place it is declared at .
. other uses of colon's are expecting pre-existing symbols .
. one brief way to type-tag a goto tag is "(to)
since that reminds one of an address .



9.6: adda/exceptions/routine-oriented:
. part of a sub's signature needs to be the exceptions it won't catch .
. but this could chg with impl,
since the exceptions it could generate depend on
who it decides to get its services from;
so then need a sub`exception detector:
.(sub; -- run the sub,
exception?
( sub`ex1: s
, sub`ex2: s
, sub`other: [type-specific ex's]
-- for exceptions from sub's servers unspecified .
)
) .


9.6: adda/exceptions/agent-oriented:
. the dialog model of exceptions would be like this:
resume if caller handled exception and requested a resume
no:
that would be a dialog not an exception .
. there are 2 styles of interactions:
. the exception is like the mac`alert .
. the other call-backs are dialogs .
. remember that the user is going through an agent;
eg, the agent typically builds a function call by
presenting an additional param dialog,
and then combining that param with any selected objects
for use as arg's to make a call .
. the agent can also help by turning exceptions into dialogs;
eg, if the app' can't find a file,
the agent can remember the request,
and restart it after asking the user to find it on another volume .

9.9: adda/interface/spec's include stack usage:
. another part of proc signature would be stack useage
as a function of input size .
. this would be a useful option when reusable with other components,
so that you could see if the sum of your components and job size
might put a strain on your memory .


9.11: adda/syntax/loops:
for .. while .. : body
. body can contain for, while without the colon,
and it has the same effect as conditional exit .
. if it has a label with type"loop, then it indicates start of loop,
and the stmt may contain conditional exits that apply to that label .
mis:
. having {while, until} in the loop will be confusing
by looking like a nested loop with a null body .
. better to just have the {exit, enter} stmt's with conditionals
for any controls not in the head of the loop .

9.11: adda/syntax/loop/{for-step-except}:

. the head of a for-loop can have these modifiers:
{step, except}:
. step works like in basic .
. for i.nat except i is odd : ... .

. real step real except eg,asymptotes .
. (step -1) goes in reverse .


9.11: adda/syntax/loop/for-loop with multiple var's:
. for-loops can have multiple var's,
and they sequence all vars in parallel until the one var ends .
eg, for (i= 1, j= 1..2) -- does 1 loop usign param'(i=1, j=1) .

9.22: adda/syntax/loop/mixing for and while:
. to solve that problem where using for and while in the same loop head
was confused with be 2 nested loops,
treat the for() like a bool,
and use it in conjunction with other bools;
eg,
for(control var) .. and (bool) : body
while () and () : body

10.5: adda/syntax/goto:
. labels that are expected to be entered from below
should be declared as loop.type,
eg, (jmp.loop: ... enter jmp) .

10.7: adda/syntax/goto labeling:
. if a label is not expected to be entred from below,
then it's type is entry else loop.type .


10.16: adda/for.loop and code.literals:

. the for() part implicitely creates a subscope,
and the loop`body -- while usually a code literal --
can also be a symbol of
type expecting an external with the same name as
that created in the for()-part .
. the explicit meaning of this:
(
for(i) and b ?? body
)
would then mean this:
body.!`= '(.<<i>>.<<b>>:  body`method(i,b) );
.(
i.t`= i`first,
b ??
( body;
i=i`last ? exit;
i`++
)-loop
)-block .
) .
10.25: adda/syntax/minimalist loops:
. if wanting to minimalize reserved symbols,
could rquire all loops to be formed by heading a stmt in a loop.type label,
eg, '(x.loop: body)
and then some sub.stmt in the body
has to be using the enter.stmt .


11.5: adda/syntax/block stmt:
. the block.stmt allows externals undecl'd;
then no way to tell local's decl'd .
.(decl list: code),
(.(params): code),
'(code) .
. use of colon conflicts with use a label,
also, we don't need a decl'section if using
the rule of
we mention type only when intending a declare .
(eg, doing an .( ... i.int ...) declares a new i.int )) .


11.10: adda/sytax/loop/reloop like recur:

. an enter.stmt from within a for-loop
is the same as a goto targeting the bottom of the for-loop;
additionally,
reloop from withing a for-loop re-initializes the for-loop
-- the same as a goto targeting
the line above the for-loop .
. at any given point in a loop
you can either exit loop,
enter loop for next iteration
or continue with current iteration .

. reloop is to loops
what recur is to anonymous functions .
[11.14:
. if it's like that,
then it should be used for nested loops, right?
could also have both: reloop and loop`recur .
]

while-loop with optional control scope:

. the model of a while-loop is
while(truth x) f x,
-- this is one place where externals
are use freq'ly in a block
f has access to an external
that controls its number of loops .

. the while-loop is another place like for-loop
where one should be able to declare
a var in a while`param that is visible to body .
. it might be simpler to keep that in for-part,
but some like to see a for-loop's control var
as not being modifiable by the loop`body .

.( x.truth`= true; for () and x ) ??
body(x);
-- this gives an option to use as control vars
either existing externals or loop-locals .
. in etree (the lisp view of the code)
( .(...)?? b )
--. that is known as a decl-loop.stmt:
decl-loop (head, body),
vs loop(head, body ) .

. it would be simpler to wrap block around loop
instead of integrating it into head;
but, that would be noisy with nested loops
-- this way gives it that c`for-loop compactness .

. what is the syntax of a for-loop that is
using current value of external
and stepping it?
for(x in {x .. limit, step}, ... ) ??
body
for (x.t) declares local x
and steps through all values of its type .
. for (x, y), steps x and y concurrrently .


11.15: adda/syntax/multi-case:
. as in loop,
enter and exit can be used in a case.stmt:
(enter) drops to the next case;
(enter ) goes to a given case;
exit has the same effect as null stmt .

adda/syntax/case:

. case as a reserved word could be a dummy symbol for the case result;
so:
x? (case <= c:...)
the use of case allows relating to arbitrary expr
so if wanting to use vars instead of literals,
use case = var .

. the way to impl adda case could get complicated:
. if the case allows variable goto targets goto x
that actually means having an array of ptr to fun,
exec'ing f#(x),
and generating a function for each case .
. mixing (enter) with (case ranges) could be confusing work .
. in vari-case,
what if multiple cases apply ?
do both in the given order ? .

11.22: adda/syntax/labels:
. to have goto labels be alarming the way ada does,
have a goto.type;
ie, the type's name is an empty dbl-angle.bracket .
. when a 1st-class function
points at a quoted goto symbol,
then the effect of eval
is to jump to the symbol's current value .
. a function that can be assigned a goto.type
must be declared goto.type .
. the way to impl' this in c
requires rolling your own variable goto:
. take all the jump.labels in the block,
and give them an enum value .
. then in the c code,
a variable goto is really a case stmt:
if( var = enum#1 ) goto label#1
else if ....
--
one way to avoid is this:
. divide the code into blocks that are between goto labels;
then jumping to a label has the same effect as
calling all the blocks below that label;
but, it also implies exiting the current routine .

12.9: adda/syntax/exceptions:
. mac-style exceptions are using this model:
. a type'mgt declares exceptions as callback functions;
meaning, they are either undefined or have a default literal,
and can be redefined by the current scope .
. ie, instead of having an ada-style exception section,
you'll see
t`exception#i`= myhandler;

12.14: adda/syntax/case:
. in a case stmt, "(is) can refer to the case:
eg, (is >= x : ...) .