scala-cookbook | Installs the Scala programming language language | Functional Programming library

The most elegant way to throw an error is your (1):

map.getOrElse(key, throw /* some Exception */)

The 2nd and 3rd options should not be used: You know which actual error can happen: the map doesn't contain the key. So wrapping it in a try, or Try, is more work than necessary. And worst, it will catch other exceptions that are not meant to be. In particular Fatal exception that should not be caught.

But, the real most elegant way to manage exceptions in scala is to actually track them with types.

A simple generic way (but sometime too generic) is to use Try. As soon as your code might fail, everything is wrapped in Try and later code is called in map and flatMap (you can use for-comprehension to make it more readable)

A more specific way is to use Either (from scala) or \/ from scalaz and explicit the type of error you are managing, such as \/(MissingData, String) for some MissingData class you've made. Eg:

Naming classes as a Controller or Service is a java convention that most of java developer follows. It is one of the many convention that we follow for good maintenance and readability of code. Nobody stops anyone for having same class name in different package. But if you ask me, it would reduce readability for sure for guys like me and we won't make any friends by doing so.

It's like one should give class/variable name in camelcase in java classes. It's a coding convention, adopted by most Java programs. It makes reading code easier as you become use to a given standard but you don't have to follow it. It's a choice that we make

Here is a revised example that you can also run on Scastie:

In all the cases you showed the fields are also parameters for the constructor.

The parameters declared to be either val or var become public members. If you use the variables in the constructor they will not become members, if you use them in the class, they will be private members.

In first case class Fizz(buzz : Buzz){} the buzz parameter is immutable and not become member (I assume you don't use it anywhere).

In second case class Fizz (val buzz : Buzz) {} the buzz parameter is immutable and become public member.

In third case class Fizz (var buzz : Buzz) {} the buzz parameter is mutable and become public member.

And again in all the cases there isn't any getter or setter created automatically.