Discussing how authentic frozen@mid80 is, in refreshing the 1980 know-how of net formalisms. All from 1980? Anything new? I am faithful in restoring -- programming with the formal-structures that were published.
informing w.r.t. frozen@mid80 1.2.1.
What I am programming in frozen@mid80, was trivial in 1980.
If anything may seem not exactly what that was with the nets of mid80, then you may ask me.
NN73 had suggested macro-compressing nets, mainly for lessening the visual clutter, and against the tedious [re]drawing of [huge] nets -- as well as a comfortable thinking-aid, that is, abstraction. Thus, when frozen@mid80 is not showing all of that as a single page of a huge net, that is fitting NN73.
The formal-machinery is surely expanding to the full net, but a human studying with that net interactively, is visiting that as a tree of macros -- similar to how your operating system is facilitating your organizing the files in your system as a hierarchy/tree of directories/folders.
The refining/abstracting as exemplified in the Fig.11 of P77, and in the Fig.3a w.r.t. Fig.7a of VD78, both show how you may manually redraw your net, to expand/compress. As frozen@mid80 does not automatize that, you need to manually redraw that, as they had done.
But if you accept the (well-thought) point of NN73 about the clutter&tediousness of big nets, this does not seem as a good strategy, and mostly, VD78 does not sound like suggesting such manual-redrawings (for zooming in/out within a single-piece graph), any way. In those examples, they show how a reduced net is equivalent to the full net. Otherwise, their point of discussing all of that, is for having packages of reduced nets, in their repositories of well-formed nets.
For representing the neighbor of a running net, NN73 refer to the neighbor/environment, while SARA people refer to that as the system. With frozen@mid80, I have taken the shortest route, by assuming that that peripheral token input/output function is patterned after the existing rezolving architecture of Nutt. That is, a function for a location, for any peripheral location. That is trivially authentic mid80.
I think, a peripheral function is not supposed to run, if that net is bound as a submacro, because the "neighbor" is the net that is invoking that as a submacro. Thus, frozen@mid80 example running the NN73 Fig.2, is running differently, as a submacro (of the example, rest=work@root). That is because there is no peripheral function to feed the new input token. The containing net is supposed to feed that input, and get the output. Obvious.
The section "Alternatives in Representation" of NN73, is reflecting on what/how we would choose from.
Note: That "single transition" is a reduced net -- reduced to one of the five framing-categories, F, J, T, X, or Y. Toggling, reduced vs. macro, is trivial -- as far as their categories are compatible.
For example, with frozen@mid80, in representing, highlight a T- or X-transition, or any (non-rezloc) location, and next, press the space bar, or CR/BS, for toggling the submacro of that row.
The F/J/Y are not different, but frozen@mid80 has not published any macros with their input/output pattern, yet. Trivial, though. Simply extend this or that arm of a F/J/X/Y with a T macro, to keep the shape of that F/J/X/Y. I have published what is fundamental & educative.
With respect to macro-toggling, three location categories are identifiable: afferent/input, intermediate, final/output. For example, the frozen@mid80 macro "absorbing" is compatible with only a final location, because that is a terminating macro, with no output. The "feeding" macro is strictly for input to the net. Any location is T compatible, in taste. Both input and output peripheral locations may refer to a T macro, too -- as well as their specific absorbing/feeding varieties.
For experimenting, we may turn a submacro off for a transition/activity, and right next toggling the equivalent frag code on (that is, the "transition procedure involving statistical terms" as NN73 suggested), as its activity.
For example, if the submacro is fork&join and we know what that two-arm macro is computing, we may choose the function that would compute that result. If arm1 is x1+=1, arm2 is x1+=3, the net-architect could summarize that as x1+=4 for replacing that submacro with a frag.
food4thought What would that stat be, if the submacro that we would be replacing were computing at a single row? (cf. menuing-loop) (Hint: The summarizing stat, that the frag would be computing, has to reflect the determinism of that submacro. If the submacro is randomizing the high-vs.-low row running, the frag summarizing that, ought to weigh with those probabilities, too.)
For toggling the frag of an activity, first press '[' or ']' to get to that list, while highlighting the row of the corresponding activity. Next, keep toggling the frag (with '[' or ']'), until the sought-for frag is found. In that list, A is the frag for activity, F/F1/F2 are for freezing, and R is for rezolving.
For example, a VD78 subnet is equivalent to a T-transition of NN73 -- and therefore, to macroloc, too. For a VD78, as a submacro, the friend/fertile location ("idle" of VD78), is double -- the friend.first is the normal within the submacro, while the friend.fantom (phantom) is "mystifying" within the submacro, as the token is getting away, not getting into the submacro immediately.
Therefore, I differentiate the two visually. The fantom loc is not on the trunk of the net.
From the point-of-view of NN73 there is nothing extra. The friend is the peripheral-loc list. in&out
The friend location, is reminding of the C++ keyword friend, too. Through that, the two macros, the containing, and the submacro, are sharing their state information, setting/getting token.
If in the net, we may find a few friendly, that would all validly act as the fertile/friend location (VD78 "idle" place, that is representing the rest of the world to that submacro), then the net-architect would choose. In representing, ^F (ctrl-F) is for choosing this/that as the friend.
The formalism is from VD78. I guess nobody would think allowing choosing this/that as the friend, is any new work. Well, I may find new uses, but that is not about the formalism. For example, frozen@mid80 is a tight program -- in spaghetti, if not DNA fashion, with overlapping sequences. The flexibility of friend-choosing, may allow capturing the structure of such a program.