Question: Is it possible to inherit a role in Java Servlet 3.0 and how? 

Let's say I have role A, B and C. In a servlet i have `if(request.isUserInRole("A")){ /* some feature only available for A */ }` and `if(request.isUserInRole("B")){ /* some feature only available for B */ }`. In web.xml are the roles defined:

```
<security-role>
    <role-name>A</role-name>
</security-role>
<security-role>
    <role-name>B</role-name>
</security-role>
<security-role>
    <role-name>C</role-name>
</security-role>

```

What I want is that every user with role C can do what A and B can without adding role A and B to user C.

Answer: 
why not replace `null` with empty string ?

```
private def div(id: String = "", cssClass: String = ""): JQuery = {
  val optId = if(id.isEmpty) None else Some(id)
  val optCssClass = if(cssClass.isEmpty) None else Some(cssClass)
  ...
  // deal with optId and optCssClass using the Scala-way™
  ...
}

```

then you can do:

```
div(id = "someId") // no cssClass
div(id = "otherId", cssClass = "someClass")

```
Most of the answers here are proposing some variant of the "null object" pattern, by denoting an empty String to mean "undefined" (as in `val optId = if(id.isEmpty) None else Some(id)`)

The catch here is that an empty string might be a valid value! This is true of **any** String, though you can mitigate the problem by using something really outrageous, possibly involving non-printable characters. e.g:

```
val UndefinedString = "THIS-IS-A-REALLY-UNLIKELY-VALID-VALUE"

private def div(
  id: String = UndefinedString,
  cssClass: String = UndefinedString
): JQuery = {
  val optId = Option(id) filter (_ != UndefinedString )
  val optCssClass = Option(cssClass) filter (_ != UndefinedString )
  ...
  // deal with optId and optCssClass using the Scala-way™
  ...
}

```

Better still, you could use a different type to denote your null object. As you can't subclass `String` you'll have to bump your params up the type hierarchy and make them `CharSequence`s

```
object NullCharSeq extends CharSequence {
  def charAt(idx: Int): Char = ???
  def length(): Int = 0
  def subSequence(start: Int, end: Int): CharSequence = this
  def toString(): String = ???
}

def charSeqToOptStr(cs: CharSequence): Option[String] = cs match {
  case NullCharSeq => None
  case x => Option(x) map (_.toString)
}

private def div(
  id: CharSequence = NullCharSeq,
  cssClass: CharSequence = NullCharSeq
): JQuery = {
  val optId = charSeqToOptStr(id)
  val optCssClass = charSeqToOptStr(cssClass)
  ...
  // deal with optId and optCssClass using the Scala-way™
  ...
}

```

It's a heavyweight pattern for one-shot usage, but the cost is quickly amortized if you use it a lot (`NullCharSeq` and `charSeqToOptStr` only need to be defined once in the codebase).

There's also zero risk of mistakenly passing your "undefined" String as though it were a valid value. Plus, you gain the ability to directly accept CharBuffer/StringBuffer/StringBuilder as your arguments.