Scala case classes and tail recursion best practices

Question

I'm fairly new to scala from java and also pretty new to pattern matching. One of the things I'm trying to get my head around is when to use it and what it's costs/benefits are. For example this

def myThing(a: Int): Int = a match {
  case a: Int if a > 0 => a
  case _ => myThing(a + 1)
}

Does the same thing as this (unless I've really misunderstood something)

def myThing(a: Int): Int = {
  if (a > 0) a
  else myThing(a + 1)
}

So my actual question: But do they run the same way? Is my pattern matched example tail recursive? And if not, then why not when it is in the second example?

Are there any other things I should worry about, like resources? Or should I pretty much always try to use pattern matching?

I've searched around for these answers but haven't found any "best practices" for this!

Edit: I'm aware that the example used is a bit contrived - I've just added it to be clear about the question below it - thanks!

Community · Accepted Answer · 2017-05-23 12:10:36Z

6

Yes they do run the same. Best practice for every syntactic sugar is the same: use it whenever it provides more readable or flexible code. In your examples in case of if statement you may omit braces and write just

def myThing(a: Int): Int =  if (a > 0) a else myThing(a + 1)

Which is definitely more handy than pattern matching. Pattern matching is handy in situations where:

You have 3 or more alternatives
You should unpack\check values through extractors (check this question)
You should check the types

Also to ensure you function is tail-recursive you could use the @tailrec annotation

edited May 23, 2017 at 12:10

CommunityBot

11 silver badge

answered Apr 18, 2015 at 19:35

Odomontois

16.4k2 gold badges38 silver badges74 bronze badges

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

Comments

Maxim · Accepted Answer · 2015-04-18 21:42:24Z

2

Another 'Scala' way to do it would be to define an extractor for a positive number

  def myThing(a: Int): Int = a match {
    case PositiveNum(positive) => positive
    case negative => myThing(negative + 1)
  }


  object PositiveNum {
    def unapply(n: Int): Option[Int] = if (n > 0) Some(n) else None
  }

answered Apr 18, 2015 at 21:42

Maxim

7,3581 gold badge34 silver badges45 bronze badges

1 Comment

mucaho Over a year ago

Overkill for this case, but very useful in more complex situations.

elm · Accepted Answer · 2015-04-19 08:05:30Z

1

Yet another way to pattern-match against the evaluated predicate (condition),

def myThing(a: Int): Int = a > 0 match {
  case true => a
  case _    => myThing(a + 1)
}

where matches include no (additional) guards or type declarations.

answered Apr 19, 2015 at 8:05

elm

20.5k15 gold badges72 silver badges116 bronze badges

2 Comments

mucaho Over a year ago

It's confusing (at least for me), so what's the benefit to write it like this?

elm Over a year ago

The best approach is an if-else expression; for pattern matching this proves a bit more concise than the original, no guards, no additional type declarations.

Collectives™ on Stack Overflow

Scala case classes and tail recursion best practices

3 Answers 3

Comments

1 Comment

2 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

1 Comment

2 Comments

Linked

Related