Operator meaning "complete fully"...what is that?

[hostilefork]

@hostilefork

I'd like something to help notice when an operation did not consume all its input.

Something along the lines of:

>> (completely-consume add 1 2)
== 3

>> (completely-consume add 1 2 3)
** Error: ADD did not completely consume args, leftover is [3]

We have this thing now. It's called APPLY.

>> apply :add [10 20 1020]
** Error: Too many values in APPLY argument block (see /RELAX)

You have to explicitly tell it to /RELAX if you want it to ignore extra parameters.

>> apply/relax :add [10 20 1020]
== 30

With the infix quoting version, you can do this succinctly.

>> add // [10 20 1020]
** Error: Too many values in APPLY argument block (see /RELAX)

Stupid (?) Idea of the Moment

Make triple slash the relaxed form of APPLY

>> add /// [10 20 1020]
== 30

@hostilefork

As an API client it would be up to you to put it at the beginning or the end (or both?)

Value *v = rebValue("||", whatever, ..., ...);

Value *v = rebValue("whatever", ..., ..., "||");

We don't technically need rebApply() and rebApplyRelax() (or rebApplyRelaxed()?) in the API, but it could save on constructing a block for the apply parameters and give a little bit more efficiency to not need to look up the APPLY operator.

 rebValue("apply", some_func, "[", arg1, arg2, arg3, "]");

 rebApply(some_func, arg1, arg2, arg3);

It's probably worth it--we'll be needing all the performance tricks we can get.

We could soft quote the first slot so you could use WORD! or TUPLE! or CHAIN! or PATH! there.

 rebApply("lib/append:dup", arg1, arg2, arg3);