My point is, everyone has a "standard model" in their head about how all programming languages work. Kind of like how the same system of DNA works in all species. We extrapolate that model based on our exposure to different languages. Being exposed to only OO languages can lead to false assumptions about the over-arching framework of language, but such is the same for strict functional, procedural, or declarative exposure. As exposure to new ideas increases, the underlying assumptions dissolve into a better understanding, and the knowledge helps inform the programmer not only on the new language but on the old languages as well.
For example, I started my journey into programmerdom with JavaScript. Going to C (strict C, not C++) was a major mind-f*, and I didn't make the transition well. When I went to Java, I became much more productive. Learning the finer details of how Java tracks references and performs parameter passing, I suddenly understood C a lot better. Once I knew C better, I realized a metric ton of flaws in my JavaScript. All because greater exposure to language informed my underlying assumptions about what language means. The jump from Java to C# enhanced my understanding of event-driven programming (merely because of how C# provides syntactical features for delegates separately from the class system). I then realized I understood WIN32 events in C a lot better. A similar experience followed my forays into F# (failed attempt into functional programming, but not unproductive), back into C#, into C++, back into Java (briefly), back into JavaScript (this time with the knowledge of first-class functions), and then into Scheme (finally a successful foray into functional programming).
A parallel can be drawn from almost any feature in one language to another feature or application of features in another. It's the essence of Turing completeness, we can emulate any system in any other system (yes, albeit not efficiently).