Solely for syntax, my assertion is that this is just because dynamic languages evolve faster. Because they are easier to build.
E.g. one person can buy the dragon book(s), use parser/lexer libraries, get an AST, and then start an interpreter than just stores objects as maps, and evals things dynamically.
But very few people are going to write a new/novel type system on their weekends.
So that's why, IMO, all the sexy/modern syntax shows up in dynamic languages first, and then takes ~a generation or two to reach static languages, where you need a dedicated team to put the effort into the type system + compiler + expected tool set (IDEs/etc.).
(E.g. see Scala, Kotlin, Rust, etc., which have all, IMO, achieved the "syntax as nice as Ruby" level, but took large teams of people to do it).
I've only reasonable experience with Rust in that list but... no. I've seen enough Scala to get that that's not true, and I know it's not true for Rust.
That's not to say that static languages can't have nice syntax - Crystal is a great example if you'r trying to match Ruby - but I don't think your examples are great.
No, but one can hack an extension to the GHC type system in a weekend. (That's one of the reasons why there are so many.)
With dynamic typing you're much more likely to break things up early precisely because you know you have to keep things in your head.
On the other hand, static typing allows you to just keep adding code and it makes sure that the code will compile and run. However, at some point you end up with a large and complex system that you don't really understand. All you know is that it's self consistent. Understanding what the business logic is doing and why can be quite difficult and the fact that it type checks does little to help you there.
Coincidentally this is the reason that static typing proponents are obsessed with refactoring. Once you realize what mess you got yourself in then you have a ton of code to refactor and there's no way you can keep track of it all in your head.
With a dynamic languages refactoring tends to happen in much shorter cycles and introduces much less cognitive load.
Now, I could just write the logic down as logical statements on paper, and check my code against it... Or I can write the logic down as logical statements on the computer, and have it check my code automatically. Pick your poison.
If you are programming with a language that forces to keep everything in your head, you'll never build big systems.
less confusion, less classes, more libraries, cleaner interfaces and easier testing.
Of those classes and libraries obviously apply per language not per typing discipline, confusion was rhetorically tied to the number of classes so again, thats about the language not the typing.
tormeh's right, the comparison was between languages, not between typing.
With so many libraries supporting my development, I usually tend to write much less code using a dynamic language. Also most of the code tends to be isolated with clear interfaces exposed to other parts of the code. Writing tests is simpler too, compared to writing them in dynamic languages.
May be large projects with hundreds of thousands of lines of code, could benefit from statically typed languages. But for majority of the projects (80-20 rule) dynamic languages offer cleaner syntax, simpler coding experience and faster time to market (my opinion).