def foo [A，B]到底是什么意思？ 输入阴影

Question

When I write a function like def foo[A,B] , what exactly does the [A,B] mean? I know it's a Polymorphic Method ; but when do you use foo [A] versus foo [A,B] ?

Here's an example where I don't understand the difference. This function compiles:

def map[B](f: A => B): Stream[B] =                                               
  foldRight(empty[B])((h,t) => cons(f(h), t))

Whereas this one doesn't compile. I don't understand why the A isn't required, after all A is referenced by the f: A => B :

def map[A,B](f: A => B): Stream[B] =                                            
  foldRight(empty[B])((h,t) => cons(f(h), t))

[error] ..../Stream.scala:61: type mismatch;
[error]  found   : h.type (with underlying type A)
[error]  required: A
[error]     foldRight(empty[B])((h,t) => cons(f(h), t))

(this is from one of the FP in Scala exercises)

Addendum

After reading the answers I'm adding some context, to help future readers. The function is defined inside a trait:

trait Stream[+A] { 
  ...
  def map[B](f: A => B):Stream[B] = 
    foldRight(empty[B])((h,t) => cons(f(h), t))
  ...
}

So the error was being caused by type shadowing , but see @acjay's excellent answer below.

Googling scala type shadowing doesn't result in a direct definition in any of the scala docs, which is interesting because as @travisbrown says below, it's "one of the most common sources of beginner confusion I've seen". There is a discussion here: Why does Scala support shadow variables?

Answer 1

In the first example, there's only one type parameter because that's not a function in isolation, it's a method in class Stream[A] , which declares the first type parameter. Approximately like so:

class Stream[A] {
  // ...

  def map[B](f: A => B): Stream[B] =                                               
    foldRight(empty[B])((h,t) => cons(f(h), t))

  // ...
}

So you get the A from the surrounding class scope. Suppose instead that you made map a method on the companion object instead. In this case, the companion object has no type parameter, so you have to define both parameters on the method:

class Stream[A] {
  // ... methods, with foldRight, but no `map`
}

object Stream {
  // ...

  def map[A, B](stream: Stream[A])(f: A => B): Stream[B] =                                               
    stream.foldRight(empty[B])((h,t) => cons(f(h), t))

  // ...
}

This second option would be used slightly differently. You would say Stream.map(myStream)(myMappingFunction) instead of myStream.map(myMappingFunction) . Both options are perfectly valid, but it's probably more idiomatic to put the method in the class.

So, to answer your question, you use multiple type parameters on a method when two or more of the arguments and/or return type need to be generic. You might also use two type parameters for classes as well, like (disregarding variance):

Type Map[A, B] - A is the key type and B is the value type

Type Tuple2[A, B] (better known as (A, B) ) - A is the type of the 1st element, B is the type of the 2nd element

Type Function1[A, B] (better known as A => B ) - A is the argument type, B is the return type

...and so on.