Unfortunately it also left me with an extremely deep distaste for dynamic types, and in particular, the blind usage of lists and maps for everything. The ML family of languages finally gave me a paradigm worth keeping around.
Working professionally in dynamic languages, especially those that use maps in place of objects/records, I would spend a lot of time trying to figure out which keys were present in various input maps. Were they always available or only sometimes? I could either add verify checks at function callsites or trace the map all the way through my code and hope it didn't originate from an undocumented API response.
A few years ago, we started migrating our code from Elixir to Scala. That involved a lot of work creating case class "schemas" for many records that used to be represented by maps. But now it's clear at dev time what data each function receives as input. What fields are required and which are optional. I can write a quick bugfix in a large module that someone else wrote without spending a full day tracing data paths and looking at runtime traces.
With static types it's obvious and you generally have to work hard (and in non intuitive ways) to mess up.
This becomes more important as team sizes grow.
Either the data type is opaque (as in you shouldn’t mess with it and you should use the provided api) or it’s just normal primitives and thus no restrictions.
You don’t usually reach into data structures to modify their properties, especially if it’s for foreign modules.
it's not blind, tho it could seem that way, and if someone hadn't thought deeply abut how they should use lists and maps, then it could be described as being blindly using them.
But this style is also what makes clojure dynamic, and flexible. Updates don't have to be rigid, and keeping backwards compatibility is a lot easier than a lot of statically typed languages.
That's not to say you can't have some rigidity where it's needed (specs for example, can be sprinkled in where you need/want it).