[SCALA] 이해를 위해 스칼라에 불일치를 입력

이해를 위해 스칼라에 불일치를 입력

왜이 건설 스칼라의 형식 불일치 오류가 발생합니까?

for (first <- Some(1); second <- List(1,2,3)) yield (first,second)

<console>:6: error: type mismatch;
 found   : List[(Int, Int)]
 required: Option[?]
       for (first <- Some(1); second <- List(1,2,3)) yield (first,second)

나는 목록 일부를 전환하면 그것을 잘 컴파일합니다 :

for (first <- List(1,2,3); second <- Some(1)) yield (first,second)
res41: List[(Int, Int)] = List((1,1), (2,1), (3,1))

이것은 또한 잘 작동 :

for (first <- Some(1); second <- Some(2)) yield (first,second)

해결법

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

   1.지능형를 들어지도 또는 flatMap 방법에 대한 호출로 변환됩니다. 이 하나의 예를 들면 :

   지능형를 들어지도 또는 flatMap 방법에 대한 호출로 변환됩니다. 이 하나의 예를 들면 :

   for(x <- List(1) ; y <- List(1,2,3)) yield (x,y)
   

   그된다 :

   List(1).flatMap(x => List(1,2,3).map(y => (x,y)))
   

   따라서, 제 1 루프의 값 (이 경우,리스트 (1))에 flatMap 메소드 호출을 수신한다. 목록에 flatMap 다른 목록을 반환하기 때문에, 이해의 결과는 물론 목록 될 것입니다. (이것은 나에게 새로운이었다 함축 항상조차 반드시 Seqs에서, 스트림에 포함되지 않는 경우.)

   이제 flatMap이 옵션에 선언되는 방법을 살펴 :

   def flatMap [B] (f: (A) ⇒ Option[B]) : Option[B]
   

   이 점을 염두에 두십시오. 보자하는 방법을 이해지도 호출 시퀀스로 변환됩니다 (일부 (1)과 하나)의 오류 :

   Some(1).flatMap(x => List(1,2,3).map(y => (x, y)))
   

   이제, 그것은 flatMap 호출의 매개 변수 목록을 반환 뭔가 있음을 쉽게 알 수 있지만 옵션은, 필요에 따라.

   일을 해결하기 위해, 다음을 수행 할 수 있습니다 :

   for(x <- Some(1).toSeq ; y <- List(1,2,3)) yield (x, y)
   

   그건 잘 컴파일합니다. 종종 가정으로 그 옵션, 서열의 하위하지 주목할 가치가있다.

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

   2.함축이 경우 첫 번째 생성자, 옵션 [지능]의 컬렉션의 형식을 반환하려고합니다 위해 쉬운 팁 기억합니다. 당신은 몇 가지 (1)로 시작한다면, 당신은 옵션의 결과 [T]를 기대한다.

   함축이 경우 첫 번째 생성자, 옵션 [지능]의 컬렉션의 형식을 반환하려고합니다 위해 쉬운 팁 기억합니다. 당신은 몇 가지 (1)로 시작한다면, 당신은 옵션의 결과 [T]를 기대한다.

   당신이 목록 유형의 결과를 원하는 경우에, 당신은 목록 생성기 시작해야합니다.

   왜 이러한 제한이 그리고 당신은 항상 순서의 어떤 종류를 할 것입니다 생각하지? 당신은 옵션을 반환하는 의미가 상황을 가질 수 있습니다. 어쩌면 당신은 당신이 옵션을 얻기 위해 무언가와 결합하려는 옵션 [지능]이 [목록 [Int 인은]], 다음과 같은 기능을 말한다 : (I : INT) => 만약 (I> 0) List.range (0 난) 밖에 없음; 일을 "이해"하지 않을 때 당신은 그 없음이 쓰기하지 않고 얻을 수 있습니다 :

   val f = (i:Int) => if (i > 0) Some(List.range(0, i)) else None
   for (i <- Some(5); j <- f(i)) yield j
   // returns: Option[List[Int]] = Some(List(0, 1, 2, 3, 4))
   for (i <- None; j <- f(i)) yield j
   // returns: Option[List[Int]] = None
   for (i <- Some(-3); j <- f(i)) yield j
   // returns:  Option[List[Int]] = None
   

   지능형 대한 일반적인 경우에 확장되는 방식 실제로 함수 (T) => M [U]를 입력 M [U]의 목적을 얻기로 형 M [T]의 객체를 결합하는 매우 일반적인 메커니즘. 당신의 예에서, M은 옵션 또는 목록을 할 수 있습니다. 일반적으로는 M. 그래서 당신이 목록과 옵션을 결합 할 수 없습니다 동일한 유형이어야합니다. 이 특성의 서브 클래스를 보면, M이 될 수있는 다른 것들의 예.

   하지만 당신이 목록 시작 작업 할 때 왜 (T) => 옵션 [T]와 [T] 목록을 결합 했습니까? 이 경우 라이브러리는 의미가 더 일반적인 형식을 사용합니다. 그래서 당신은에 이동하여 목록을 결합 할 수 있습니다과에 이동에 옵션에서 암시 적 변환이 있습니다.

   당신이 표현이 돌아가 첫 번째 생성자와 같은 유형으로 시작하려는 유형에 대해 생각 : 결론은 이것이다. 필요한 경우 해당 유형에 랩.

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

   3.아마 옵션이의 Iterable없는 함께 할 수있는 뭔가가. 암시 Option.option2Iterable는 반복 가능 컴파일러로 제 예상되는 경우를 처리한다. 나는 컴파일러 마법 루프 변수의 종류에 따라 다르다는 것을 기대합니다.

   아마 옵션이의 Iterable없는 함께 할 수있는 뭔가가. 암시 Option.option2Iterable는 반복 가능 컴파일러로 제 예상되는 경우를 처리한다. 나는 컴파일러 마법 루프 변수의 종류에 따라 다르다는 것을 기대합니다.

4. ==============================

   4.난 항상이 정보가 도움이 발견 :

   난 항상이 정보가 도움이 발견 :

   scala> val foo: Option[Seq[Int]] = Some(Seq(1, 2, 3, 4, 5))
   foo: Option[Seq[Int]] = Some(List(1, 2, 3, 4, 5))
   
   scala> foo.flatten
   <console>:13: error: Cannot prove that Seq[Int] <:< Option[B].
      foo.flatten
          ^
   
   scala> val bar: Seq[Seq[Int]] = Seq(Seq(1, 2, 3, 4, 5))
   bar: Seq[Seq[Int]] = List(List(1, 2, 3, 4, 5))
   
   scala> bar.flatten
   res1: Seq[Int] = List(1, 2, 3, 4, 5)
   
   scala> foo.toSeq.flatten
   res2: Seq[Int] = List(1, 2, 3, 4, 5)
   

from https://stackoverflow.com/questions/4719592/type-mismatch-on-scala-for-comprehension by cc-by-sa and MIT license