spec: Rephrase confusing paragraph about TailLoop inputs/outputs

[acl-cqc]

I read this as part of #557 and was just bewildered, so thought I'd see if I can do better. Admit it's not easy! How does this strike you?

[ss2165]

I do think this is better but the last sentence still seems to come out of nowhere. I think it might be better to explicitly declare two signatures (including the extra row in both), one for the child graph and one for the node, and then describe the logic in the text below.

[acl-cqc]

but the last sentence still seems to come out of nowhere

Yes! I've tried putting an explicit row-catenation #(i|o),#x in throughout, somewhat of the same idea as you suggest. The tuple unpacking now seems like a stuck-on extra, but maybe that's harmless....?

[ss2165]

This is better but I still feel it would be better with notation. Something like

Suggested change

	These provide tail-controlled loops: the dataflow sibling graph within the
	TailLoop-node computes a value of 2-ary `Predicate(#i, #o)`, as well as
	a row `#x` of other values (perhaps empty). The first variant means to
	repeat the loop with the computed values fed in at the top of the DSG,
	which has inputs `#i,#x`; the second variant means to exit the loop
	and output `#o,#x` from the TailLoop node. (In both cases the tuple
	within the Predicate is unpacked.) Thus, the contained graph may be
	evaluated more than once, with the first iteration using the inputs
	to the TailLoop node: `#i,#x`.
	These provide tail-controlled loops. The node has a `FunctionType`
	```
	#I:#X -> #O:#X
	```
	where `#I, #O, #X` are rows and `:` expresses row concatenation.
	Correspondingly, the dataflow sibling graph inside the TailLoop-node has `FunctionType`
	```
	#I :#X -> (Predicate(#I, #O)):#X
	```
	The `Predicate` type variants signal loop continuation or termination.
	The first variant means to
	repeat the loop with the computed values (`#I:#X`) fed in at the top of the DSG;
	the second variant means to exit the loop
	and output `#O:#X` from the TailLoop node. (In both cases the tuple
	within the Predicate is unpacked.) Thus, the contained graph may be
	evaluated more than once, with the first iteration using the inputs
	to the TailLoop node.

I'm not sure what notation to pick to be consistent with the rest of the spec - there isn't much elsewhere.

[acl-cqc]

Ok, so I haven't found a definitive notation either, but have rewritten as something of an intermediate form to what you suggest. It feels that there are a lot of concepts to get across altogether, but many have also been used for Conditional, so if this doesn't pass muster, maybe we should define more row operations/notations in common to the Control Flow section?

[ss2165]

I am happy with this version, however I do think some shared predicate(/choice)+row notation for the control flow section is useful.