The question is a bit unclear. Is one programming style more "error-prone" than another? What would this mean? Humans cause errors, not programs. However, some programming styles are better at mitigating certain types of human error. I think it's reasonable to say that a compiled language that doesn't give a syntax error at compile-time is more error-prone than one that does, and it is this sense that I will use.
Some languages do provide more mitigation than others. For instance, statically typed languages provide errors that mitigate type violations*. In some languages, such as Haskell, the type system is so powerful that "getting the types right is most of the battle". I would argue that these languages provide more mitigation than others. That is to say, it is easier to have unexpected type violations in dynamically typed languages, but that does not make them worse languages
So, no language will make humans less error-prone, so no language is less error-prone per se. But some languages will have more effective mitigation strategies that will catch human errors before they become user-facing bugs.
Of course, none of this will make a bad programmer good, nor does it replace more robust mitigation strategies like unit testing.
* This is not to say that dynamically typed languages are strictly more error-prone, only that there is a class of bug (type violation) that will not be mitigated directly by the language.