[SCALA] 스칼라 튜플에 기능 콤비를 사용?

스칼라 튜플에 기능 콤비를 사용?

'지도'는 튜플이 합리적인 것 같습니다에 그래서를 사용하여 요소의 수를 유지합니다.

지금까지 내 시도 :

scala> (3,4).map(_*2)    
error: value map is not a member of (Int, Int)
       (3,4).map(_*2)
             ^
scala> (3,4).productIterator.map(_*2)
error: value * is not a member of Any
       (3,4).productIterator.map(_*2)
                                  ^
scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2)
res4: Iterator[Int] = non-empty iterator

scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2).toList
res5: List[Int] = List(6, 8)

그것은 아주 고통스러운 모습 ... 그리고 난 튜플로 다시 변환하려고하기 시작하지 않았습니다. 내가 잘못을하고 있습니까? 도서관이 향상 될 수 있을까요?

해결법

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

   1.무형의 지원 매핑 및 중간 HList 표현을 통해 튜플을 통해 접이식,

   무형의 지원 매핑 및 중간 HList 표현을 통해 튜플을 통해 접이식,

   샘플 REPL 세션,

   scala> import shapeless._ ; import Tuples._
   import shapeless._
   import Tuples._
   
   scala> object double extends (Int -> Int) (_*2)
   defined module double
   
   scala> (3, 4).hlisted.map(double).tupled
   res0: (Int, Int) = (6,8)
   

   튜플의 요소는 다른 유형의 어디에 있는지, 유형별 사례와 다형성 기능을 매핑 할 수 있습니다

   scala> object frob extends Poly1 {
        |   implicit def caseInt     = at[Int](_*2)
        |   implicit def caseString  = at[String]("!"+_+"!")
        |   implicit def caseBoolean = at[Boolean](!_)
        | }
   defined module frob
   
   scala> (23, "foo", false, "bar", 13).hlisted.map(frob).tupled
   res1: (Int, String, Boolean, String, Int) = (46,!foo!,true,!bar!,26)
   

   최신 정보

   볼품 2.0.0-M1 매핑으로 튜플을 통해 직접 지원됩니다. 위의 예는 지금과 같이

   scala> import shapeless._, poly._, syntax.std.tuple._
   import shapeless._
   import poly._
   import syntax.std.tuple._
   
   scala> object double extends (Int -> Int) (_*2)
   defined module double
   
   scala> (3, 4) map double
   res0: (Int, Int) = (6,8)
   
   scala> object frob extends Poly1 {
        |   implicit def caseInt     = at[Int](_*2)
        |   implicit def caseString  = at[String]("!"+_+"!")
        |   implicit def caseBoolean = at[Boolean](!_)
        | }
   defined module frob
   
   scala> (23, "foo", false, "bar", 13) map frob
   res1: (Int, String, Boolean, String, Int) = (46,!foo!,true,!bar!,26)
   

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

   2.지도는 이해가되지 않습니다 그래서 일반적으로, 튜플의 요소 유형은 동일하지 않습니다. 당신은하지만, 특별한 경우를 처리하는 함수를 정의 할 수 있습니다 :

   지도는 이해가되지 않습니다 그래서 일반적으로, 튜플의 요소 유형은 동일하지 않습니다. 당신은하지만, 특별한 경우를 처리하는 함수를 정의 할 수 있습니다 :

   scala> def map[A, B](as: (A, A))(f: A => B) = 
        as match { case (a1, a2) => (f(a1), f(a2)) } 
   map: [A,B](as: (A, A))(f: (A) => B)(B, B)
   
   scala> val p = (1, 2)    
   p: (Int, Int) = (1,2)
   
   scala> map(p){ _ * 2 }
   res1: (Int, Int) = (2,4)
   

   당신은 p.map (_ * 2)으로 이것을 호출하는 포주 내 도서관 패턴을 사용할 수 있습니다.

   최신 정보

   원소의 종류가 동일하지 않은 경우에도, Tuple2 [A, B]는 bimap 동작으로 매핑 될 수 Bifunctor이다.

   scala> import scalaz._
   import scalaz._
   
   scala> import Scalaz._
   import Scalaz._
   
   scala> val f = (_: Int) * 2
   f: (Int) => Int = <function1>
   
   scala> val g = (_: String) * 2
   g: (String) => String = <function1>
   
   scala> f <-: (1, "1") :-> g
   res12: (Int, String) = (2,11)
   

   업데이트 2

   http://gist.github.com/454818

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

   3.매핑 함수는 A => B 복귀 F [B]를 얻는다.

   매핑 함수는 A => B 복귀 F [B]를 얻는다.

   def map[A, B](f: A => B) : F[B]
   

   retronym가 Tuple2 [A, B]입니다 Bifunctor을 쓴, 그래서 당신은 scalaz 또는 고양이의 bimap 기능도 찾아보실 수 있습니다. bimap는 튜플의 양쪽을 매핑하는 기능입니다 :

   def bimap[A, B, C, D](fa: A => C, fb: B => D): Tuple2[C, D]
   

   (일반적 우측 값) 튜플 [A, B]가 2 개 값을 보유하고 있으며 단지 하나의 값에 매핑 될 수 있으므로 단지 왼쪽에 대해 동일한 값을 반환하며 바로 사용 기능은 튜플의 오른쪽 값을 통해지도한다.

   (3, 4).bimap(identity, _ * 2)
   

from https://stackoverflow.com/questions/2339863/use-functional-combinators-on-scala-tuples by cc-by-sa and MIT license