Looking at some practical examples of the consequences, of course every time you want to assign a function you now have to say /foo: func [...] [...] instead of just foo: func [...] [...]. While that may seem a little irritating when it's FUNC, it's actually helpful when you're using something else... like someone reading /foo: cascade [...] for the first time will know that CASCADE is a function generator. So it's more helpful than it seems, and it's an easy-to-hit key on the keyboard.
it definitely pushes refinements down in terms of how much they stand out:
for-each [abbrev expansion] data [
replace:all sig unspaced [space abbrev space] unspaced [space expansion]
replace:all sig unspaced [space abbrev newline] unspaced [space expansion]
]
response: copy:part lowercase ask ["Okay?" text!] 1
if response = "y" [break]
surname: across to ","
thru space [opt some space]
[firstnames: across to "("] (trim:head:tail firstnames)
title: between "(" ")"
Colon just doesn't "pop" as much as slash does.
But I think this is the correct tradeoff, because it means slash now pops as showing you where functions are being called or defined, which is more significant.
We're getting more bang for our character buck.
Emulation of historical Redbol gets tricky. But new techniques could address it, when and if it becomes a priority for...someone.
BUT WAIT, THERE'S MORE: AN INSANEO-STYLE BENEFIT!
-
path means execute function
-
chain in path means pick refinement
-
tuple in chain means provide argument there !!!
This gives us what everyone always wanted.
>> lib/append:dup [a b c] [d e] 2
== [a b c [d e] [d e]]
>> lib/append:dup.2 [a b c] [d e]
== [a b c [d e] [d e]]
>> lib/append:dup.2:line [a b c] [d e]
== [
a b c [d e]
[d e]
]
And it means we can do away with skippable parameter hacks (in fact, we can do away with skippable parameters altogether):
>> compose:only.<*> [(1 + 2) (<*> 10 + 20) (100 + 200)]
== [(1 + 2) (30) (100 + 200)]
(That's an actual legitimate use of an :ONLY refinement...)
It would be literal, so you'd have to use a GROUP! to evaluate. So if (a: '**)
>> a: <*>
>> compose:only.(a) [(1 + 2) (** 10 + 20) (100 + 200)]
== [(1 + 2) (30) (100 + 200)]
Stratospheric: CHAIN! as The Function Call Dialect
What if you offered the ability to pass the chain to the function so it could handle it itself?
>> all:not [1 > 2, 3 > 4, 5 > 6]
== ~true~ ; anti
Instead of being constrained to a finite number of refinements, you could interpret it how you wanted.
Maybe a version numbering scheme to make the same function have different behaviors, without needing more than one top level declaration... something:1 vs. something:2 as a shorthand for something:version.1 and something:version.2 ?
Hence compose:<*> could be the presumed way to give the limit of what you compose. You could even change the interpretation of parentheses or fences or blocks...
>> compose:[$] [a b c [1 + 2] [$ 10 + 20] (100 + 200)]
== [a b c [1 + 2] 30 (100 + 200)]
>> compose:(a) [a b c [1 + 2] (a 10 + 20) (100 + 200)]
== [a b c [1 + 2] 30 (100 + 200)]
Sky is no longer the limit.
This Is Looking Like A Done Deal
Not only is this going to give greater readability, greater security/sanity, a more coherent model for things I've bumped up against... but it's features I now don't think I can live without.
I will be beginning the change shortly.