[function] 스칼라에서 “리프팅”이란 무엇입니까?

몇 가지 사용법이 있습니다.

부분 기능

a PartialFunction[A, B]는 도메인의 일부 하위 집합에 대해 정의 된 함수입니다 A( isDefinedAt메소드에서 지정한대로 ). a를 PartialFunction[A, B]로 들어 올릴 수 있습니다 Function[A, Option[B]]. 즉, 전체 에 대해 정의 A되었지만 값이 유형 인 함수Option[B]

에 대한 메소드 lift를 명시 적으로 호출하여 수행됩니다 PartialFunction.

scala> val pf: PartialFunction[Int, Boolean] = { case i if i > 0 => i % 2 == 0}
pf: PartialFunction[Int,Boolean] = <function1>

scala> pf.lift
res1: Int => Option[Boolean] = <function1>

scala> res1(-1)
res2: Option[Boolean] = None

scala> res1(1)
res3: Option[Boolean] = Some(false)

행동 양식

메소드 호출을 함수로 “리프팅”할 수 있습니다. 이것을 에타 확장 이라고합니다 (벤 제임스에게 감사합니다). 예를 들어 :

scala> def times2(i: Int) = i * 2
times2: (i: Int)Int

밑줄 을 적용하여 메소드를 함수로 들어 올립니다.

scala> val f = times2 _
f: Int => Int = <function1>

scala> f(4)
res0: Int = 8

방법과 기능의 근본적인 차이점에 유의하십시오. (함수) 유형 res0의 인스턴스 (즉, 값 )(Int => Int)

펑터

펑은 (에 의해 정의 된 scalaz ) 일부 “용기”(나는 용어 사용이다 매우 느슨하게을) F우리가있는 경우 같은 것을 F[A]하고 기능을 A => B, 우리는 우리의 손을 얻을 수 있습니다 F[B]예를 들어, (생각 F = List과 map방법 )

이 속성을 다음과 같이 인코딩 할 수 있습니다.

trait Functor[F[_]] {
  def map[A, B](fa: F[A])(f: A => B): F[B]
}

이것은 기능 A => B을 functor의 영역으로 “리프팅”할 수있는 동형 입니다. 그건:

def lift[F[_]: Functor, A, B](f: A => B): F[A] => F[B]

즉, Ffunctor 인 경우 함수 A => B가 있고 함수가 F[A] => F[B]있습니다. lift메소드를 시도하고 구현할 수 있습니다 -그것은 사소한 것입니다.

모나드 트랜스포머

으로 hcoopz가 (난 그냥이 불필요한 코드의 톤을 쓰는 저를 저장 한 것을 깨달았다) 아래 말한다, 용어 “리프트”도 내에서 의미가 모나드 변압기 . 모나드 변압기는 모나드를 서로 쌓아 올리는 방법입니다 (모나드는 작성하지 않음).

예를 들어,를 반환하는 함수가 있다고 가정합니다 IO[Stream[A]]. 이것은 모나드 변압기로 변환 될 수 있습니다 StreamT[IO, A]. 이제 다른 가치를 “상승”하고 싶을 IO[B]수도 있습니다 StreamT. 당신은 이것을 쓸 수 있습니다 :

StreamT.fromStream(iob map (b => Stream(b)))

아니면 이거:

iob.liftM[StreamT]

이 질문 구걸 이유가를 변환 할 할 IO[B]로를 StreamT[IO, B]? . 대답은 “구성 가능성을 활용하는 것”입니다. 기능이 있다고 가정 해 봅시다f: (A, B) => C

lazy val f: (A, B) => C = ???
val cs =
  for {
    a <- as                //as is a StreamT[IO, A]
    b <- bs.liftM[StreamT] //bs was just an IO[B]
  }
  yield f(a, b)

cs.toStream //is a Stream[IO[C]], cs was a StreamT[IO, C]

답변

f: List[A] -> List[B]
f(xs) = f(xs(1)), f(xs(2)), ..., f(xs(n))

f: Set[A] -> Set[B]
f(xs) = \bigcup_{i = 1}^n f(xs(i))

f: List[A] -> List[B]
f(xs) = xs map f

Seq(1,2,3).lift
Int => Option[Int] = <function1>

Seq(1,2,3).lift(2)
Option[Int] = Some(3)

Seq(1,2,3).lift(22)
Option[Int] = None

Seq(1,2,3).lift(2).getOrElse(-1)
Int = 3

Seq(1,2,3).lift(22).getOrElse(-1)
Int = -1

import play.api.libs.json._
import play.api.libs.functional.syntax._

case class Location(lat: Double, long: Double)

implicit val locationWrites: Writes[Location] = (
  (JsPath \ "lat").write[Double] and
  (JsPath \ "long").write[Double]
)(unlift(Location.unapply))