[SCALA] 익명 함수의 인수 유형은 완벽하게 알고 있어야합니다. (8.5 SLS)

익명 함수의 인수 유형은 완벽하게 알고 있어야합니다. (8.5 SLS)

나는 함수 리터럴을

{case QualifiedType(preds, ty) =>
               t.ty = ty ;
               Some((emptyEqualityConstraintSet,preds)) }

오류 메시지에서 어떤 결과

missing parameter type for expanded function The argument types of an anonymous function
must be fully known. (SLS 8.5) Expected type was:
? => Option[(Typer.this.EqualityConstraintSet, Typer.this.TypeRelationSet)]

나는 SLS 8.5 보였지만, 설명을 찾지 못했습니다.

나는 함수 나 자신을 확장하는 경우

{(qt : QualifiedType) =>
  qt match {case QualifiedType(preds, ty) =>
               t.ty = ty ;
               Some((emptyEqualityConstraintSet,preds)) }}

오류가 사라집니다.

(ㄱ)이 오류가?

(나) 나는 그것을 해결하기 위해 무엇을 할 수 있는가?

패턴과 =>하지만,이는 구문 오류 사이 QualifiedType : 나는 명백한 추가했습니다 수정을 시도했다.

내가 발견 한 것은 문맥이 차이를 만드는 것입니다. 나는 QualifiedType => B 기대로 선언 된 함수에 인수로 함수 리터럴을 사용하는 경우, 오류가 없습니다. 내가 A => B를 기대 함수에 인수로 사용한다면, 오류가 있습니다. 나는 패턴이 생각할 수있는 유형이 QualifiedType의 슈퍼 인 객체에 적용 할 수 있기 때문에 어떤 여기에가는 것은, 그런 것을 기대 컴파일러는 함수가 적용되지 않습니다 보증없이 명백한 유형을 지정하고자하지 않습니다 QualifiedType가 아닌 것은. 정말 내가하고 싶은 것을 쓸 수있다 {QualifiedType (preds, 타이) => ...} 그것은 하스켈의 \ QualifiedType (preds, 타이)과 같은 뜻이 -> ...

해결법

1. ==============================

   1.여기에 우리의 나머지 부분에 대한 SLS 견적이있다 :

   여기에 우리의 나머지 부분에 대한 SLS 견적이있다 :

   그렇지 않으면, 당신은 당신의 질문에 대답했다.

2. ==============================

   2.이 X. 보통의 슈퍼의 것을 제외하고 {경우 X (X) => ...} 부분적인 기능이지만, 컴파일러는 여전히 '이 있기 때문에 당신이 경우 문제가되지 않습니다, 귀하의 의견 유형이 무엇인지 모르는 익명 함수를 다시 쓰고, 형태는 문맥에서 공지되어있다. 그러나 여기 당신이 유형을 제공 할 수있는 방법입니다 :

   이 X. 보통의 슈퍼의 것을 제외하고 {경우 X (X) => ...} 부분적인 기능이지만, 컴파일러는 여전히 '이 있기 때문에 당신이 경우 문제가되지 않습니다, 귀하의 의견 유형이 무엇인지 모르는 익명 함수를 다시 쓰고, 형태는 문맥에서 공지되어있다. 그러나 여기 당신이 유형을 제공 할 수있는 방법입니다 :

   case class Foo(x: Int)
   
   // via annotation
   val f: Foo => Int = { case Foo(x) => x }
   
   // use pattern matching
   val f = (_: Foo) match { case Foo(x) => x }
   
   // or more normally, write as a method
   def f(a: Foo) = a match { case Foo(x) => x }
   def f(a: Foo) = a.x
   

   당신은 아마 함수 리터럴을 사용하여 나타났습니다로 / 여기에 패턴 매칭은 매우 의미가있다. 귀하의 경우 그냥 일반적인 방법이 필요 같다 :

   def whatever(qt: QualifiedType) = {
     t.ty = qt.ty
     Some((emptyEqualityConstraintSet, qt.preds)) 
   }
   

   당신은 변경 가능한 상태를 제거하기 위해 리팩토링해야하지만.

3. ==============================

   3.내가 함수 리터럴을 사용하고 싶었 두 번 유형을 반복하는 것을 좋아하지 않는 이유는 여기에있다. 나는 모든 옵션 일치하는 코드에서 요소에 대한 내 자신의 제어 구조를 구축을 위해 노력했다. 너무 많은 오버 헤드가 있다면, 제어 구조는 도움이되지 않습니다. 여기에 내가하고 싶었던 것입니다

   내가 함수 리터럴을 사용하고 싶었 두 번 유형을 반복하는 것을 좋아하지 않는 이유는 여기에있다. 나는 모든 옵션 일치하는 코드에서 요소에 대한 내 자신의 제어 구조를 구축을 위해 노력했다. 너무 많은 오버 헤드가 있다면, 제어 구조는 도움이되지 않습니다. 여기에 내가하고 싶었던 것입니다

   //This is the control construct definition
   def switch[A,B]( x : Option[A], noneFun : =>B, someFun : A=>B) = x match {
       case None => noneFun 
       case Some(y) => someFun(y) }
   
   //And this is an example of using it.
   def foobar( qt : Option[QualifiedType]  ) = 
       switch( qt, {reportError("SNAFU");None},
               {case QualifiedType(preds, ty) =>
                  Some((emptyEqualityConstraintSet,preds)) } ) 
   

   스위치 제어 구조는 벌금을 컴파일하지만, SLS 내가하는 A이 경우, 나는 "명확한 유형"을 가져야한다고 말한다 있기 때문에 사용에 오류가 발생했습니다. 함수 리터럴 ( "경우"로 종류)의이 종류의 인수가 전혀 합법적으로 어떤 일이 될 수있는 부분 기능을위한 것입니다 때문이다. 나는 INT 내 함수 리터럴을 주장 할 수와 그 유형 오류,하지만 단지 실패의 모든 패턴의 문제가되지 않을 것입니다. 컴파일러가 알고 정보 "하향식"일부 필요 그래서, 나는 "확장 기능 리터럴"의 매개 변수에 의도 입력 즉, 다음에 X를 위해 넣어 무엇을

   {(x : X) => x match {case Some(QualifiedType(preds, ty)) =>
                  Some((emptyEqualityConstraintSet,preds)) } }
   

   컴파일러 could't 내가 QualifiedType와 부분적인 기능과 다음의 Unify을하지 않을 있는지 스위치의 종류를 사용하는 이유 궁금하다. 그러나 그것은하지 않습니다.

   어쨌든 그것은 컴파일되지 않습니다. 그러나 모든과를 대체하는 것은 오류를 제거합니다. 다음 코드는 실제로 컴파일합니다. 내가 잃을 것은 어떤 유형 검사이다.

   //This is the control construct definition
   def switch[A,B]( x : Option[A], noneFun : =>B, someFun : A=>B) = x match {
       case None => noneFun 
       case Some(y) => someFun(y) }
   
   //And this is an example of using it.
   def foobar( qt : Option[QualifiedType]  ) = 
       switch( qt, {reportError("SNAFU");None},
               {case QualifiedType(preds, ty) =>
                  Some((emptyEqualityConstraintSet,preds)) } ) 
   

   내가 알고 싶네 (가) 내가 원하는 것을 이미 라이브러리 기능이있는 경우 스위치의 위의 정의가 개선, 그리고 (b) 할 수있는 경우.

   여기에 마지막 코드입니다. 예, 나는 그것이 배 (catamorphism)라고 생각합니다.

   def switch[A,B]( x : Option[A])(noneFun : =>B, someFun : A=>B) = x match {
       case None => noneFun 
       case Some(y) => someFun(y) }
   
   def foobar( qt : Option[QualifiedType]  ) : Option[(EqualityConstraintSet, TypeRelationSet)] =
       switch( qt )({reportError("SNAFU");None},
               {case QualifiedType(preds, ty) =>
                  Some((emptyEqualityConstraintSet,preds)) } ) 
   

   루이지 감사합니다.

from https://stackoverflow.com/questions/12869251/the-argument-types-of-an-anonymous-function-must-be-fully-known-sls-8-5 by cc-by-sa and MIT license