難しいです

parfun1.scala

lazy val fab: PartialFunction[Base, Int] = {
  case A(base) => 1 + fabc(base) // PartialFunction#apply の呼び出し。危ない！
  case B(left, right) => 1 + fabcd(left) + fabcd(right) // 同様
}

// 全域関数だと scala コンパイラにはわからない！
lazy val fabcd: PartialFunction[Base, Int] = fab orElse {
  case C => 1
  case D => 2
}

// けど楽
def impl(base: Base): Option[Int] = fab.lift(base)

parfun2.scala

lazy val fa: A => Int = { case A(base) => 1 + fabc(base) }
lazy val fb: B => Int = { case B(left, right) => 1 + fabcd(left) + fabcd(right) }

// 全域関数だと scala コンパイラにはわかる
lazy val fabcd: Base => Int = {
  case A(_) @ a => fa(a)
  case B(_) @ b => fb(b)
  case C => 1
  case D => 2
}

// コードの重複が…
def impl(base: Base): Option[Int] = Some(base).collect {
 case A(_) @ a => fa(a)
 case B(_) @ b => fb(b)
}

type.scala

sealed trait Base
case class A(base: Base) extends Base
case class B(left: Base, right: Base) extends Base
case object C extends Base
case object D extends Base