sullyj3

Functions can be polymorphic in their effectfulness, so the coloring problem isn't. Functions only become incompatible where you've made them incompatible on purpose - the whole point of annotating functions' effectfulness is to statically know you're not accidentally invoking particular effects where you promised you wouldn't.

Can you elaborate or point to resources?

That only shows that word prediction isn't necessary, not that it's insufficient

It could be a tmux alternative if the session persistence is the only feature of tmux you care about, and you don't like the rest of it.

Learning a new language is basically trivial relative to the effort of bootstrapping everything yourself to compensate for a lacking ecosystem, or the effort of banging your head against the fundamental unsuitability of a tool for a job.

Anyone who's learned one or two languages should be able to pick up the basics of any of the standard ones pretty much instantaneously.

Which is which and why?

Whenever you're asking for an explanation this deep in the ontology stack, you need to think about what kind of explanation would be satisfying to you, and whether you can reasonably expect intuitive answers in domains that lie far outside of your everyday experience. Human brains aren't built to grasp this stuff intuitively.

At a certain point, the reason we like some particular wacky physical model is always going to be "it has the best combination of explanatory power and simplicity"

Why not just make a separate leaderboard for autonomous AI solvers which are an interesting problem in their own right?

> I feel like right-to-left requires you to think to the end of a line before you start typing anything at all

Maybe this will make people tend to shorter lines, counterbalancing the natural tendency towards incomprehensibility of array and stack languages

The fact that you embed the entire program in the URL is a hilarious demonstration of its brevity

well, nfnl transpiles it for you

It's a runtime check. The following fennel:

    (fn add-1 [x] (+ x 1))

    (lambda add-2 [x] (+ x 2))

transpiles to the following lua:

    local function add_1(x)
      return (x + 1)
    end
    local function add_2(x)
      _G.assert((nil ~= x), "Missing argument x on /home/sullyj3/tmp/fn-vs-lambda/fnl/x.fnl:3")
      return (x + 2)
    end
    return add_2

For that you'd use Applicative

  (*) <$> [1..10] <*> [2,3,5]
  -- or
  liftA2 (*) [1..10] [2,3,5]

Admittedly also not accessible to non-haskellers. But on the other hand, if you're going to learn a language, you ought to learn its idioms at some point.