(*
If exprBranchSequence is an ExpressionBranch, then�
�invokes or assigns each recognized Name or creates NewNames as required by the ordered execution of each element in �exprBranchSequence� and the environmental facts.
*)
Name[NameStringQ,
Pattern[Name[Pattern[Type[String]]]]
]
Name[CardinalQ,
Pattern[Type[Cardinal]]]
]
To understand the following see Type[name][Function][atom]'s specification.
*)
Name[Reckon[Expression[Branch]][Type[exprBranchSequence, Pattern[Sequence]]],
Cast[{slotSpecs, atom, head, handle},
Name[slotSpec, Slot[Sequence]],
Name[handle, Type[head][Function][atom]],��� (* note1 *)
����������������������� If[Pattern[handle][Not[True]],������������������������������ (* note2 *)
����������������������������������� Noop[atom]
Name[handle, Type[head][Function][Noop[atom]]],
Branch[handle,
CardinalQ, (* The ExpressionAtom is in memory accessed through the Cardinal handle. *)
����������������������������������������������� insertExpressionHandle[handle, slotSpec],
Pattern[Type[Noop]], ���������������������������������� (* note3 *)
����������������������������������������������� Noop[Reckon[Expression[Branch]][handle]]
True,�������������������������������������������������������������� (* note4 *)
����������������������������������������������� Noop[Reckon[Expression[Branch]][UnrecognizedAtom[handle, atom]]]]
]
], exprBranchSequence]
]]
(*
note1
If type is the Name of a DataType, then�
Type[type][Function]
�is assigned to the Function which converts binary code into the type�s value. A Cardinal identifying a handle is returned.� See TypeNameFunction.
note2
If some Type has some region of its domain that does not map anywhere, but should, and atom is such an out-of-bounds specimen, then�
����������������������� Noop[atom]
�can invoke a procedure that returns a handle to an alternate mechanism of getting a result.� If this programming approach is adopted, then Noop[atom] must be subsequently unassigned.� Otherwise, an infinite recursion will result�
The downside of this approach is that "Noop[atom]" cannot be then used as output notice that
Whether it does this or not is entirely dependent on the Type's implementation.� In general, however, any Type that fails to deliver a handle to part of its defined domain is "still in development."� Using the Noop[atom] mechanism to invoke alternate procedures to create See TypeNameFunction.
note3
Pattern[Type[head]] (also written as "_head") matches Expressions with (Head), head.
note3
"Type[name][Function][atom]" has failed to generate its intended result.
*)
(*
registerType[Type[type, Type[Name]][Type[arg, BinaryStringQ]]
[Head[atom], Slot[Sequence][atom]]
�installs the Type, type, with binary argument, arg.
*)
Name[registerType[type_, arg_],
(* This is a C storage and pointer assignment function. *)
]
(*
invoke[name] is called when name is known to be in the environment.
name is placed on the EvaluationStack.
*)
Name[invoke[name_], AppendTo[EvaluationStack, name]]
The Name[] set defines the environment.
insertName[�nam�] inserts �nam� into the recognized Name[] lexicon.
Name[] is a special purpose set written and implemented in C, and maintained by the Grok32` Kernal.
nameSetInsertion[name] is part of the C implementation.
Not[name] is put into the EvaluationStack because it is a new name and thus we already know it will not evaluate to anything. By wrapping name in Not[�] we are noting that there is no reason to attempt invocation with name.
*)
�],
AppendTo[EvaluationStack, Not[name]]
�indicates that expr is uninterpretable?