Using scala.Option functionally

Question

I have an Option, say O, which can either be None or may have some value inside. If it has some value, that value may have a flag, say f. My requirement is that if O is None, then I create an object, say of type MyEntity,but if O has a value with flag as true, I return Nil else I create instance of MyEntity with different value. Java code can be almost as:

if(O.isEmpty) {
  MyEntity("x")
} else {
  if(O.f) {
     Nil
   } else {
    MyEntity("y") // with different value
   }
}

I want to do this in functional style using HoFs provided in scala.Option. What would be best possible way of doing it? I could this so far :

if(O.isEmpty){
 MyEntity("x")
} else {
 Option.unless(O.exists(_.f))(MyEntity("y"))
}

The return that would be Any since that si the upper bound between MyEntity and Nil are you sure you want that? Also, it may help if you provide the definition of the value inside the Option - In any case, I would write this using pattern matching rather than higher order functions. — Luis Miguel Mejía Suárez
– Luis Miguel Mejía Suárez, Commented Mar 24, 2021 at 17:17
Nil is a name of an empty list. The proper Scala code would be returning Option[MyEntity] and the implementation would be something like O.filterNot(_.f).map(_ => MyEntity("y")) — Oleg Pyzhcov
– Oleg Pyzhcov, Commented Mar 24, 2021 at 17:17
@OlegPyzhcov that doesn't work since the value inside MyEntity is different for the empty case and the non-empty but no-flag case. — Luis Miguel Mejía Suárez
– Luis Miguel Mejía Suárez, Commented Mar 24, 2021 at 17:20

Randomness Slayer · Accepted Answer · 2021-03-28 19:15:33Z

1

I misread your question the first go round, so here is attempt #2

This is a great case for pattern matching:


val maybeMyEntity: Option[MyEntity] = option match {
    case Some(flagValue) if flagValue => None
//  case Some(true) => None (More concise, but does not highlight a handy feature)
    case Some(_) => Some(MyEntity("Y"))
    case None => Some(MyEntity("X"))
}

Pattern matching is very powerful.

Alternatively, mapping is another option:

mapping of an Option will only occur if its value is not empty, and flatMapping will remove the layer of Option added, from Option[Option[MyEntity]] to Option[MyEntity]

val result: Option[MyEntity] = if (option.isEmpty) {
    Some(Entity("X"))
} else {
    option.flatMap { flagValue =>
        if (flagValue) {
            None
        } else {
            Some(MyEntity("Y"))
        }
    }
}

edited Mar 28, 2021 at 19:15

answered Mar 24, 2021 at 23:12

Randomness Slayer

7393 silver badges22 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Luis Miguel Mejía Suárez Over a year ago

case Some(true) would look better, also you are not wrapping in Some the correct answers.

Randomness Slayer Over a year ago

@LuisMiguelMejíaSuárez could you clarify what you mean by "you are not wrapping in Some the correct answers"? I'm afraid I don't follow.

Randomness Slayer Over a year ago

But as to the case Some(true) would "look" better, that may be the case (looks "better" is very subjective, and clarity is paramount to stylistic choices imho), but I wanted to keep the structure as similar to that in the question posted. My hope was that the solution is very analogous to the attempt, and thus hopefully easier to understand.

Randomness Slayer Over a year ago

@LuisMiguelMejíaSuárez I see what you mean with the Some, I've corrected it. Thank you!

Dima · Accepted Answer · 2021-03-24 17:57:43Z

0

As mentioned in the comments, Nil type is a List, and your expression should always return the same type (should really not be Any).

One possibility is to define a "sentinel" value for MyEntity, e.g.:

object MyEntity {
   val Nil = MyEntity("")
}

Now you can write:

   val result = O.fold(MyEntity("x")) { 
      case true => MyEntity.Nil
      case false => MyEntity("y")
   }

answered Mar 24, 2021 at 17:57

Dima

40.6k6 gold badges54 silver badges80 bronze badges

Comments

jwvh · Accepted Answer · 2021-03-25 06:50:50Z

0

    case class AnOption(var flag: Boolean = true)
    
    case class MyEntities(name: String)
    
    val myOptionEntityCheck = (someOption: Option[AnOption]) => {
      someOption match {
        case None => Some(MyEntities("X"))
        case Some(aValue: AnOption) if aValue.flag => None
// OR   case Some(AnOption(true)) => None
        case Some(_) => Some(MyEntities("y"))
      }
    }

edited Mar 25, 2021 at 6:50

jwvh

51.3k7 gold badges42 silver badges70 bronze badges

answered Mar 25, 2021 at 6:27

Shan Hadoop Learner

1075 bronze badges

1 Comment

Shan Hadoop Learner Over a year ago

you are correct, for beginner it is bit confusing so added extra guard for easy understanding. Thanks jwvh

Collectives™ on Stack Overflow

Using scala.Option functionally

3 Answers 3

4 Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related