So normal caveats apply, this is all personal opinion, experience, etc. I recognize many people like Scala, it has lots of use out there, I am in no way denigrating its use in production by experienced developers, etc etc.

I have both an OO and a functional background at this point. OO was in Java, Smalltalk, and Ruby, and functional has been predominantly in Erlang. I have used both paradigms exclusive of the other. So I should find Scala exciting, since it combines the two, right? Well...no. I'm really not a fan. Why?

First, I've come to really embrace functional coding. To where OO just seems unnecessary. Many problems that seem ideal for OO...still end up more elegantly implemented in functional paradigms (though are sometimes more work to figure out). A lot of the Scala gurus seem to end up predominantly functional coders, where objects are just a way of organizing their code in lieu of modules. Occasionally inheritance and whatnot may come in handy, but oftentimes it's an unnecessary part of the language. So it mostly ends up as a functional language.

Still, though, having the option of OO is good, right? I mean, more options? Well...no. One of the things I like about FP is it forces me to do the right thing more often. Having immutability be the default (or only) option means I'll write my code that way; having it coexist on equal terms with mutable code means I'm always tempted to take the easy (but likely problematic) route. And mixing paradigms on large scale projects seems...exceptionally dangerous.

Having both paradigms ends up reflective of the common issue people have with Scala; too many options. Too many paradigms, too many syntax choices to achieve the same effect, too many ways to make things implicit, too many decisions you as a programmer have to make. "This is really elegant" - yeah, sure, if you wrote it; it's extremely cryptic if you are just reading someone else's code though. Etc.

I started trying to learn Scala as my first FP language. I mean, it makes sense, I know OO, so this way I can ease my way into learning FP, right? Well...no. It never worked out that way. Having that escape hatch of mutability, having that distraction of OO type hierarchies, meant I never was forced to figure out how to do things immutably, never really saw the benefits of organizing my code into composable functions rather than these 'objects' (type hierarchies feel like bikeshedding to me now; sometimes they can be useful, but too often it's just architectural masturbation; how do we avoid painting ourselves into a corner, when if we just put them into modules based on what makes sense right now, and weren't concerned with type, we could easily move functions around as makes sense later when requirements change, without destabilizing this entire hierarchy).

I'm not saying you can't learn FP in a mixed paradigm language, only that I personally did not have the discipline or knowledge to do so in a reasonable time (too many features; which ones allow me to write functional code, vs which ones lead me to more OO? The ones I know, and think in, and am most familiar, are the OO ones, and FP is kind of an abstract term, how do I make sense of this and use the right bits to force me to learn something new?) What worked for me was going straight into a fairly concise language that forced a number of FP concepts on me (Erlang), and solving problems with that. I was grokking things within a week or two, and actually writing some non-terrible code within a month (still plenty of terrible code, as my +2 years of experience self reflects on, but some of it was actually tolerable). I did not manage that with Scala.

Now, with all that said, I feel like if I went back to Scala, I could use it as an FP language (and possibly even mix some OO if there was just an obvious benefit). I'd still have to figure out what syntax choices to use and which to avoid, I'd still have to avoid some bad design choices, things which aren't unique to Scala, but which the language presents you with more choices in. I personally find that distasteful, if I needed a JVM language I'd probably go Clojure, since it has design choices that better match my own preferences, but that's just it, it's a matter of taste.