The "implicit argument" feature seems really neat. I've grown really tired of needing to thread some random flag through all of creation to pass it to some dark corner of the code.
I agree, but with this system you'd still need to update all the "implicit" blocks (which surround every function which passes on the implicit argument) to add the new flag. I'd love to see something closer to full dynamic scope, where you don't even need the "implicit" blocks.
Yikes, thought we learned that implicit implicits are a bad idea.
Genuinely curious as to your thoughts on why this is bad... Can't say I'm v familiar
It's about context and readability. The more implicitness you work into your language, the less you know about a block of code just by reading that block.
Sure, but that doesn't make features like this automatically bad -- it's a tradeoff between completely local understanding and extra specificity that may or may not be helpful. For example, most languages will implicitly choose a meaning for "+" (integer addition, floating-point addition, etc.) based on the types involved. That's usually a better choice than making the programmer write (and read) a more specific form like "Float.+" or "Int.+".
Oh definitely, I'm not disputing that. It's a spectrum, and different people will be more or less comfortable with different amounts of explicitness/implicitness. The grand-something-parent was talking about "implicit implicits" which... without some more context (heh), sounds like it might be a bit off the deep end.
Racket has a really interesting way of doing things. It has sort of global variables that can be set for only a limited time and are only seen by the setting thread.