OCaml works for me: it's readable and about as succinct as Python. Though of course the ecosystem is much smaller.

Good choice but I tried it but couldn't get on with it to be honest. That's just down to me, not the language though.

I'm not saying it's not clunky, but all in all it's fairly pragmatic. That said, I'm a big Python fan as well. Of all the dynamic languages I work/worked with, it's the one that tries hardest to be less of a footgun, and it has a strong tradition of decent documentation (hear, hear, OCaml library developers...).

That was what I wanted before I found Scala. If your dislike for OCaml was about syntax or ecosystem then you might also like Scala.

I disklike Scala. I want less runtime baggage if possible or at least a nice wrapper around it (like venv is in python 3.4)

I'm not sure I understand. I use the maven shade plugin, so all there is at runtime is the JVM (system package) and the jar (built from libraries, but all of that's handled nicely with maven and its plugins), which can be fetched by http(s) from the repository and then just run (java -jar xyz.jar). There's no wrapping at the filesystem level but there doesn't need to be, because the classpath lets code load everything it needs from within that one jar file.

That's ok until it goes wrong at which point you need to know the JVM inside out and Maven.

I do know a lot about them but don't desire retaining that information :)

Shrug; I've found I spend less time debugging non-scala code when working in scala than I spend debugging non-python code when working in python. (When many popular python libraries go wrong, you need to know C).

I know C so that's fine for me.

It just doesn't suit me that is all.

Clojure + core.typed sounds like an ideal balance to me. I haven't actually used it yet but I might for my next side project.

http://typedclojure.org/

Or even better: opt-in dynamic as in C#.