[generics] 스칼라에서 더 높은 종류의 유형은 무엇입니까?

약간의 모호함을 가지고이 혼란을 시작해 보도록하겠습니다. 나는 사람들이 그것에 익숙한 경향이 있기 때문에 이것을 설명하기 위해 가치 수준에 비유를 사용하고 싶습니다.

형식 생성자는 형식을 “구성”하기 위해 형식 인수에 적용 할 수있는 형식입니다.

값 생성자는 값을 “구성”하기 위해 값 인수에 적용 할 수있는 값입니다.

값 생성자는 일반적으로 “함수”또는 “방법”이라고합니다. 이 “생성자”는 “다형성”이라고도하며 (다양한 “모양”의 “재료”를 구성하는 데 사용될 수 있기 때문에) 또는 “추상화”(다른 다형성 인스턴스화 사이의 변화에 ​​대해 추상화하기 때문에)입니다.

추상화 / 다형성의 맥락에서 1 차는 추상화의 “단일 사용”을 의미합니다. 타입에 대해 추상화하면 한 번만 추상화되지만 해당 유형 자체는 어떤 것도 추상화 할 수 없습니다. Java 5 제네릭은 1 차입니다.

위의 추상화 특성에 대한 1 차 해석은 다음과 같습니다.

형식 생성자는 적절한 형식을 “구성”하기 위해 적절한 형식 인수에 적용 할 수있는 형식입니다.

값 생성자는 적절한 값을 “구성”하기 위해 적절한 값 인수에 적용 할 수있는 값입니다.

value 1나 type 과 같은 추상화가 필요하지 않다는 것을 강조하기 위해 (나는 이것을 “제로 순서”라고 부를 수는 있지만 어디에서나 이것을 보지 못했다)) String보통 우리는 무언가가 “적절한”값 또는 타입이라고 말한다.

적절한 값은 인수를 기다리지 않는다는 의미에서 “즉시 사용 가능”합니다 (추상하지 않음). 그것들을 쉽게 인쇄 / 검사 할 수있는 값으로 생각하십시오 (함수를 직렬화하는 것은 부정 행위입니다!).

올바른 유형은 값을 분류하는 유형 (값 생성자를 포함)이며, 유형 생성자는 값을 분류하지 않습니다 (먼저 올바른 유형을 적용하려면 올바른 유형 인수에 적용해야 함). 유형을 인스턴스화하려면 적절한 유형이어야합니다 (그러나 충분하지는 않습니다). (추상 클래스이거나 액세스 권한이없는 클래스 일 수 있습니다.)

“고차”는 단순히 다형성 / 추상화의 반복 사용을 의미하는 일반적인 용어입니다. 다형성 유형과 값에 대해서도 같은 의미입니다. 구체적으로, 고차 추상화는 무언가를 추상화하는 무언가를 추상화합니다. 유형의 경우 “고급”이라는 용어는보다 일반적인 “고급”의 특수 목적 버전입니다.

따라서 우리의 특성화의 상위 버전은 다음과 같습니다.

형식 생성자는 형식 인수 (적절한 형식 또는 형식 생성자)에 적용하여 적절한 형식 (생성자)을 “구성”할 수있는 형식입니다.

값 생성자는 값 인수 (적절한 값 또는 값 생성자)에 적용하여 적절한 값 (생성자)을 “구성”할 수있는 값입니다.

따라서 “고차”는 단순히 “X에 대한 요약”이라고 말할 때 실제로 의미합니다! 요약 된 X것은 자체 “추상 권”을 잃지 않습니다. 원하는 모든 것을 추상화 할 수 있습니다. (그런데, 나는 여기서 “추상적”이라는 동사를 사용하여 다음을 의미한다 : 값이나 유형의 정의에 필수적이지 않은 것을 생략하여 추상화 사용자가 인수로 다양하게 제공 할 수 있도록하는 것 .)

다음은 적절한 1 차 및 고차 값과 유형에 대한 몇 가지 예 (Lutz의 전자 메일 질문에서 영감을 받음)입니다.

                   proper    first-order           higher-order

values             10        (x: Int) => x         (f: (Int => Int)) => f(10)
types (classes)    String    List                  Functor
types              String    ({type λ[x] = x})#λ   ({type λ[F[x]] = F[String]})#λ

사용 된 클래스는 다음과 같이 정의되었습니다.

class String
class List[T]
class Functor[F[_]]

클래스 정의를 통한 간접적 인 것을 피하려면 스칼라에서 직접 표현할 수없는 익명 유형 함수를 어떻게 든 표현해야하지만 구문 유형 오버 헤드없이 구조적 유형을 사용할 수 있습니다 ( #λ-스타일은 https : //.com/stackoverflow.com / users / 160378 / retronym afaik) :

익명 유형 함수를 지원하는 몇 가지 가상 버전의 스칼라에서는 예제에서 마지막 줄을 다음과 같이 단축 할 수 있습니다.

types (informally) String    [x] => x              [F[x]] => F[String]) // I repeat, this is not valid Scala, and might never be

(개인적으로, “고급 유형”에 대해 이야기 한 것을 후회하는 것은 유감입니다. 결국 유형일뿐입니다. 반드시 명확하게해야 할 때, “유형 생성자 매개 변수”, “유형 생성자 멤버”와 같은 것을 말하는 것이 좋습니다. 올바른 유형에 대해서만 말하는 것이 아니라는 점을 강조하기 위해

ps : 문제를 더 복잡하게하기 위해, “다형성”은 다른 방법으로 모호 Forall T, T => T합니다. 구조 유형으로 작성 {def apply[T](x: T): T = x})

답변

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

scala> :help kind

:kind [-v] <type>
Displays the kind of a given type.

scala> trait Foo[A]
trait Foo

scala> trait Bar[F[_]]
trait Bar

scala> :kind -v Foo
Foo's kind is F[A]
* -> *
This is a type constructor: a 1st-order-kinded type.

scala> :kind -v Foo[Int]
Foo[Int]'s kind is A
*
This is a proper type.

scala> :kind -v Bar
Bar's kind is X[F[A]]
(* -> *) -> *
This is a type constructor that takes type constructor(s): a higher-kinded type.

scala> :kind -v Bar[Foo]
Bar[Foo]'s kind is A
*
This is a proper type.

scala> :help kind

:kind [-v] <type>
Displays the kind of a given type.

    -v      Displays verbose info.

"Kind" is a word used to classify types and type constructors
according to their level of abstractness.

Concrete, fully specified types such as `Int` and `Option[Int]`
are called "proper types" and denoted as `A` using Scala
notation, or with the `*` symbol.

    scala> :kind Option[Int]
    Option[Int]'s kind is A

In the above, `Option` is an example of a first-order type
constructor, which is denoted as `F[A]` using Scala notation, or
* -> * using the star notation. `:kind` also includes variance
information in its output, so if we ask for the kind of `Option`,
we actually see `F[+A]`:

    scala> :k -v Option
    Option's kind is F[+A]
    * -(+)-> *
    This is a type constructor: a 1st-order-kinded type.

When you have more complicated types, `:kind` can be used to find
out what you need to pass in.

    scala> trait ~>[-F1[_], +F2[_]] {}
    scala> :kind ~>
    ~>'s kind is X[-F1[A1],+F2[A2]]

This shows that `~>` accepts something of `F[A]` kind, such as
`List` or `Vector`. It's an example of a type constructor that
abstracts over type constructors, also known as a higher-order
type constructor or a higher-kinded type.