> I don't know what a "container" might be
It's some poor man crap that mimics the IBM mainframes from 1970s.
> I have programmed in Python, Ruby, and Haskell, but if you think nothing has fundamentally changed in the last 30 years, good for you.
Smalltalk, Simula, Lisp, ML, Miranda, all are over 30 years old. Python, Ruby and Haskell did not bring anything fundamentally new.
And I've programmed in Smalltalk, Simula, Lisp (of various flavors), ML, Miranda, C, BCPL, MCPL, Occam, zed (probably not the one you're thinking of), BASIC (probably not the one you're thinking of), ForTran (probably not the one you're thinking of, or that one either) and more, and to me, there's a great deal to learn to get to Haskell, OCaml, etc., and even more to learn to get into the current ecosystems.
What exactly? If all that "new" stuff is just a poor, crappy execution of the concepts that had been around for over 30 years. There is nothing new to learn, same old stuff presented slightly differently.
> it's all the crap you need to learn
Do you really need to learn something as simple as a new syntax for the same old stuff? I hope you're not memorising APIs and command line arguments - it's always better to look this stuff up as you go.
> there's a great deal to learn to get to Haskell, OCaml
Mind naming any fundamentally new concepts introduced by Haskell or OCaml? Type classes? Not that new, and still worse than the good old SML modules. STG? Implementation minutiae. Or you're referring to "learning" the ghc command line options and things like hackage? Things you can look up in seconds are not worth any "learning".
Applicative functors seems an example of something "new" as the paper introducing it is form 2008.
Which concepts exactly?
> Applicative functors seems an example of something "new"
Too small a thing to be fundamental, to require any degree of re-learning.
Of course there is a lot of new fancy syntax sugar and all that, but the nature of the lazy languages did not change a bit since Miranda. If you knew Miranda, you'll learn Haskell in no time, and 30 years in between them would not make it any harder.
But yeah, since Turing and Church the fundamentals of computation hasn't changed. Nil novum sub sole
So, back to the point: anyone who knew how to program 30 years ago would easily pick it up now, without any significant learning.
For OCaml:
- row polymorphism (in particular polymorphic variants)
- higher-order and applicative functors (not the Haskell thing).
- first-class modules
For both:
- Higher-rank polymorphism
For Haskell (and now in both):
- GADTs
By introduced here, I'm ignoring them being implemented in toy languages first (since that is simply the first step of introducing them to programming). Similarly, it is not reasonable to say that F-omega or a dependently typed calculus already had such features, because that ignores issues of type inference and efficient implementation.