如果语句中的 Scala 类型不匹配

Question

Wondering why this code is not working, Am I missing something?

def treemin(lst: List[Any]): Int = {
  var MaVar: Int = 1000{
  case (sum,leaf: Int)  =>
    if(leaf < MaVar) {MaVar = leaf}
  }
}

The error I have occur here:

if(leaf < MaVar) {MaVar = leaf}

Error:

Error: type mismatch; found: Unit required: Int

I already had a look here but I didn't manage to solve this issue since I am new to scala, it might be a silly error.

Note: Is this a good approach to get the minimum leaf of a tree?

I got a Tree:

And I am trying to do a function which will return the min leaf, for example here it would return 2.

Answer 1

There are actually two errors in your code:

def treemin(lst: List[Any]): Int = {
  var MaVar: Int = 1000{
  case (sum,leaf: Int)  =>
    if(leaf < MaVar) {MaVar = leaf}
  }
}

The first error is this one:

         var MaVar: Int = 1000{
                              ^
On line 2: error: Int(1000) does not take parameters
       }
       ^

Here, you are trying to call 1000 with an argument, as if it were a function. It is not quite clear what you are trying to achieve here. Are you trying to create a new lexical scope? Then, you need to add an empty line so that Scala doesn't interpret your curly braces as an argument to 1000 :

def treemin(lst: List[Any]): Int = {
  var MaVar: Int = 1000

  {
    case (sum,leaf: Int)  =>
      if(leaf < MaVar) {MaVar = leaf}
  }
}

However, now you get another error, because now the curly braces are interpreted as creating an anonymous function:

         {
         ^
On line 4: error: missing parameter type for expanded function
       The argument types of an anonymous function must be fully known. (SLS 8.5)
       Expected type was: Int

There are ways to work around that, but the thing is: it doesn't make sense to create a new lexical scope here, since you don't define any variables in it, so there is nothing to "scope" in the first place.

Just get rid of it:

def treemin(lst: List[Any]): Int = {
  var MaVar: Int = 1000
  case (sum,leaf: Int)  =>
    if(leaf < MaVar) {MaVar = leaf}
}

Now, we get another error:

         case (sum,leaf: Int)  =>
         ^
On line 3: error: '}' expected but 'case' found.

Which essentially tells us that a case should go together with a match statement. Since it is not really clear to me what you are trying to match against, I cannot fix the code any further.

This brings us to the second error, which is actually pretty simple:

       }
       ^
On line 6: error: type mismatch;
        found   : Unit
        required: Int

This is pointing to the closing curly brace of your method, and it says essentially that you promised in your method definition that the method returns an Int , but you are actually returning Unit . In fact, you are not explicitly returning anything at all . If you don't explicitly return anything, then the value of the last expression evaluated inside the method is returned.

In this case, it is actually hard to understand what the last expression that is evaluated is going to be, since there is an error in the method, and so the method will never be evaluated at all anyway. But, let's look at the two candidates:

var MaVar: Int = 1000

This is an assignment. Assignments evaluate to Unit , so if this were the last expression evaluated, then the return value would indeed be () which is the singleton instance of Unit .

The other candidate for the last expression evaluated inside the method is the conditional expression:

if(leaf < MaVar) {MaVar = leaf}

Now, what is the value of a conditional expression? Well, it is the value of whatever branch was taken, and the type of the conditional expression is the lowest common ancestor of the types of the two branches.

The "true" branch in your conditional expression is again an assignment, and as we established above, an assignment evaluates to () aka Unit .

The "false" branch in your conditional doesn't exist , but it has to evaluate to something if it is taken, because in Scala, everything is an expression (there are no statements) and thus everything evaluates to a value . Well, the value that represents the absence of a sensible return value is (you guessed it) () aka Unit .

So, however you look at it, your method always returns Unit whereas it actually promises to return an Int . That's why get the type error.

There are a couple of other oddities with your method: It takes an argument, but never uses it. And, the argument is of type List[Any] , which is a huge red flag. Scala has a very powerful type system, there is almost never the case that you don't know what specific type something is. Any is the most useless type, since it does not tell you anything about what the type is and what it can do.