В Scala что означает" extends (A => B) " для класса case?

A => B сокращенно Function1[A, B], так как Memo расширяет функцию от A to B, наиболее заметно определяется с помощью метода apply(x: A): B который должен быть определен.

из-за обозначения" infix " вам нужно поставить круглые скобки вокруг типа, т. е. (A => B). Вы также можете написать

case class Memo[A, B](f: A => B) extends Function1[A, B] ...

или

case class Memo[A, B](f: Function1[A, B]) extends Function1[A, B] ...

чтобы завершить ответ 0_,fibonacci будет instanciated через применение метода Memoсопутствующий объект, автоматически генерируемый компилятором с Memo является классом case.

это означает, что для вас генерируется следующий код:

object Memo {
  def apply[A, B](f: A => B): Memo[A, B] = new Memo(f)
}

Scala имеет специальную обработку для apply метод: его имя не нужно вводить при вызове. Два следующих вызова строго эквивалентны:

Memo((a: Int) => a * 2)

Memo.apply((a: Int) => a * 2)

на case блок известный как сопоставление шаблонов. Под капотом он генерирует частичную функцию-то есть функцию, которая определена для некоторых из его входных параметров, но не обязательно для всех из них. Я не буду вдаваться в детали частичных функций, поскольку это не относится к делу (этой это записка, которую я написал себе на эту тему, Если вы заинтересованы), но что это по существу означает, что case блок фактически является экземпляром частичная функция.

если вы последуете этому ссылка, вы увидите, что PartialFunction выходит Function1 - что является ожидаемым аргументом Memo.apply.

ну и что, что код на самом деле означает, когда обессахаренный (если это слово), является:

lazy val fibonacci: Memo[Int, BigInt] = Memo.apply(new PartialFunction[Int, BigInt] {
  override def apply(v: Int): Int =
    if(v == 0)      0
    else if(v == 1) 1
    else            fibonacci(v - 1) + fibonacci(v - 2)

  override isDefinedAt(v: Int) = true
})

обратите внимание, что я значительно упростил способ сопоставления шаблонов, но я думал, что начинаю обсуждение unapply и unapplySeq было бы не по теме и запутанно.

Я оригинал автор делает memoization таким образом. Вы можете увидеть некоторые примеры использования в том же файле. Он также работает очень хорошо, когда вы хотите запомнить несколько аргументов из-за того, как Scala разворачивает кортежи:

    /**
     * @return memoized function to calculate C(n,r) 
     * see http://mathworld.wolfram.com/BinomialCoefficient.html
     */
     val c: Memo[(Int, Int), BigInt] = Memo {
        case (_, 0) => 1
        case (n, r) if r > n/2 => c(n, n-r)
        case (n, r) => c(n-1, r-1) + c(n-1, r)
     }
     // note how I can invoke a memoized function on multiple args too
     val x = c(10, 3) 

еще одно слово об этом extends (A => B): the extends здесь не требуется, но необходимо, если экземпляры Memo должны использоваться в функциях более высокого порядка или ситуациях.

без этого extends (A => B), это совершенно нормально, если вы используете Memo экземпляр fibonacci в вызовы методов.

case class Memo[A,B](f: A => B) {
    private val cache = scala.collection.mutable.Map.empty[A, B]
    def apply(x: A):B = cache getOrElseUpdate (x, f(x))
}
val fibonacci: Memo[Int, BigInt] = Memo {
    case 0 => 0
    case 1 => 1
    case n => fibonacci(n-1) + fibonacci(n-2)
}

например:

Scala> fibonacci(30)
res1: BigInt = 832040

но когда вы хотите использовать его в функциях более высокого порядка, у вас будет несоответствие типа ошибка.

Scala> Range(1, 10).map(fibonacci)
<console>:11: error: type mismatch;
 found   : Memo[Int,BigInt]
 required: Int => ?
              Range(1, 10).map(fibonacci)
                               ^

так extends здесь только помогает ID экземпляра fibonacci другим, что у него есть apply метод и, таким образом, может выполнять некоторые задания.