แปลงรายการ Scala เป็นทูเปิลหรือไม่

ฉันจะแปลงรายการที่มี (พูด) 3 องค์ประกอบเป็นทูเพิลขนาด 3 ได้อย่างไร

ตัวอย่างเช่นสมมติว่าฉันมีval x = List(1, 2, 3)และฉันต้องการแปลงเป็น(1, 2, 3)ไฟล์. ฉันจะทำเช่นนี้ได้อย่างไร?

คุณไม่สามารถทำได้ด้วยวิธีที่ปลอดภัย ทำไม? เนื่องจากโดยทั่วไปเราไม่สามารถทราบความยาวของรายการได้จนกว่าจะถึงรันไทม์ แต่ "ความยาว" ของทูเปิลจะต้องถูกเข้ารหัสในประเภทของมันและด้วยเหตุนี้จึงเป็นที่รู้จักในเวลาคอมไพล์ ตัวอย่างเช่น(1,'a',true)มีชนิดซึ่งเป็นน้ำตาล(Int, Char, Boolean) Tuple3[Int, Char, Boolean]เหตุผลที่ทูเปิลมีข้อ จำกัด นี้ก็คือต้องสามารถจัดการกับประเภทที่ไม่เป็นเนื้อเดียวกันได้

คุณสามารถทำได้โดยใช้ตัวแยกสกาลาและการจับคู่รูปแบบ ( ลิงค์ ):

val x = List(1, 2, 3)

val t = x match {
  case List(a, b, c) => (a, b, c)
}

ซึ่งส่งคืนทูเพิล

t: (Int, Int, Int) = (1,2,3)

นอกจากนี้คุณสามารถใช้ตัวดำเนินการตัวแทนหากไม่แน่ใจเกี่ยวกับขนาดของรายการ

val t = x match {
  case List(a, b, c, _*) => (a, b, c)
}

ตัวอย่างการใช้ไม่มีรูปร่าง :

import shapeless._
import syntax.std.traversable._
val x = List(1, 2, 3)
val xHList = x.toHList[Int::Int::Int::HNil]
val t = xHList.get.tupled

หมายเหตุ: คอมไพลเลอร์ต้องการข้อมูลบางประเภทเพื่อแปลงรายการใน HList ว่าเหตุผลที่คุณต้องส่งข้อมูลประเภทไปยังtoHListเมธอด

Shapeless 2.0เปลี่ยนไวยากรณ์บางส่วน นี่คือโซลูชันที่อัปเดตโดยใช้ไม่มีรูปร่าง

import shapeless._
import HList._
import syntax.std.traversable._

val x = List(1, 2, 3)
val y = x.toHList[Int::Int::Int::HNil]
val z = y.get.tupled

ปัญหาหลักคือประเภทสำหรับ. toHListล่วงหน้า โดยทั่วไปแล้วเนื่องจาก tuples มีข้อ จำกัด ในการใช้งานการออกแบบซอฟต์แวร์ของคุณอาจให้บริการได้ดีกว่าด้วยโซลูชันอื่น

อย่างไรก็ตามหากคุณกำลังสร้างรายการแบบคงที่ให้พิจารณาวิธีแก้ปัญหาเช่นนี้และใช้แบบไม่มีรูปร่าง ที่นี่เราสร้าง HList โดยตรงและประเภทพร้อมใช้งานในเวลาคอมไพล์ โปรดจำไว้ว่า HList มีคุณสมบัติทั้งจากรายการและประเภท Tuple กล่าวคือสามารถมีองค์ประกอบที่มีประเภทต่างๆเช่น Tuple และสามารถแมปกับการดำเนินการอื่น ๆ เช่นคอลเล็กชันมาตรฐาน HLists ใช้เวลาสักครู่ในการทำความคุ้นเคยแม้ว่าคุณจะยังคงเหยียบอย่างช้าๆ

scala> import shapeless._
import shapeless._

scala> import HList._
import HList._

scala>   val hlist = "z" :: 6 :: "b" :: true :: HNil
hlist: shapeless.::[String,shapeless.::[Int,shapeless.::[String,shapeless.::[Boolean,shapeless.HNil]]]] = z :: 6 :: b :: true :: HNil

scala>   val tup = hlist.tupled
tup: (String, Int, String, Boolean) = (z,6,b,true)

scala> tup
res0: (String, Int, String, Boolean) = (z,6,b,true)

แม้จะมีความเรียบง่ายและไม่เหมาะสำหรับรายการที่มีความยาว แต่ก็ปลอดภัยสำหรับประเภทและคำตอบในกรณีส่วนใหญ่:

val list = List('a','b')
val tuple = list(0) -> list(1)

val list = List('a','b','c')
val tuple = (list(0), list(1), list(2))

ความเป็นไปได้อีกประการหนึ่งเมื่อคุณไม่ต้องการตั้งชื่อรายการหรือทำซ้ำ (ฉันหวังว่าใครบางคนสามารถแสดงวิธีหลีกเลี่ยงส่วน Seq / ส่วนหัว):

val tuple = Seq(List('a','b')).map(tup => tup(0) -> tup(1)).head
val tuple = Seq(List('a','b','c')).map(tup => (tup(0), tup(1), tup(2))).head

FWIW ฉันต้องการให้ทูเพิลสร้างฟิลด์จำนวนหนึ่งขึ้นมาและต้องการใช้น้ำตาลวากยสัมพันธ์ของการกำหนดทูเปิล เช่น:

val (c1, c2, c3) = listToTuple(myList)

ปรากฎว่ามีน้ำตาลวากยสัมพันธ์สำหรับกำหนดเนื้อหาของรายการด้วย ...

val c1 :: c2 :: c3 :: Nil = myList

ดังนั้นไม่จำเป็นต้องมีสิ่งทอหากคุณมีปัญหาเดียวกัน

คุณไม่สามารถทำได้ด้วยวิธีที่ปลอดภัย ใน Scala รายการเป็นลำดับความยาวตามอำเภอใจขององค์ประกอบบางประเภท เท่าที่ระบบประเภทรู้xอาจเป็นรายการของความยาวโดยพลการ

ในทางตรงกันข้ามต้องทราบความเป็นเอกภาพของทูเปิลในเวลาคอมไพล์ มันจะละเมิดการรับประกันความปลอดภัยของระบบประเภทที่อนุญาตให้มอบหมายได้xประเภททูเพิลได้

ในความเป็นจริงด้วยเหตุผลทางเทคนิคสิ่งทอของ Scala ถูก จำกัด ไว้ที่ 22 องค์ประกอบแต่ขีด จำกัด ไม่มีอยู่ใน 2.11 อีกต่อไปขีด จำกัด คลาสเคสถูกยกขึ้นใน 2.11 https://github.com/scala/scala/pull/2305

เป็นไปได้ที่จะเขียนโค้ดฟังก์ชันด้วยตนเองที่แปลงรายการขององค์ประกอบได้ถึง 22 รายการและแสดงข้อยกเว้นสำหรับรายการขนาดใหญ่ การสนับสนุนเทมเพลตของ Scala ซึ่งเป็นคุณลักษณะที่กำลังจะมาถึงจะทำให้สิ่งนี้กระชับมากขึ้น แต่นี่จะเป็นการแฮ็กที่น่าเกลียด

หากคุณแน่ใจมากว่า list.size ของคุณ <23 ใช้มัน:

def listToTuple[A <: Object](list:List[A]):Product = {
  val class = Class.forName("scala.Tuple" + list.size)
  class.getConstructors.apply(0).newInstance(list:_*).asInstanceOf[Product]
}
listToTuple: [A <: java.lang.Object](list: List[A])Product

scala> listToTuple(List("Scala", "Smart"))
res15: Product = (Scala,Smart)

นอกจากนี้ยังสามารถทำได้shapelessโดยใช้แผ่นสำเร็จรูปน้อยลงโดยใช้Sized:

scala> import shapeless._
scala> import shapeless.syntax.sized._

scala> val x = List(1, 2, 3)
x: List[Int] = List(1, 2, 3)

scala> x.sized(3).map(_.tupled)
res1: Option[(Int, Int, Int)] = Some((1,2,3))

เป็นประเภทที่ปลอดภัย: คุณจะได้รับNoneหากขนาดทูเปิลไม่ถูกต้อง แต่ขนาดทูเพิลต้องเป็นตัวอักษรหรือfinal val(สามารถแปลงเป็นได้shapeless.Nat)

ใช้การจับคู่รูปแบบ:

val intTuple = List(1,2,3) match {case List(a, b, c) => (a, b, c)}

โพสต์ 2015 เพื่อให้คำตอบของ Tom Crockett มีความชัดเจนมากขึ้นนี่คือตัวอย่างจริง

ตอนแรกก็งง ๆ tuple(list(1,2,3))เพราะผมมาจากงูหลามที่คุณก็สามารถทำได้
เป็นภาษาสกาลาหรือไม่? (คำตอบคือ - ไม่เกี่ยวกับ Scala หรือ Python แต่เกี่ยวกับประเภทคงที่และประเภทไดนามิก)

นั่นเป็นสาเหตุให้ฉันพยายามหาปมว่าทำไม Scala ถึงทำสิ่งนี้ไม่ได้

ดำเนินตัวอย่างรหัสต่อไปtoTupleวิธีการซึ่งมีชนิดปลอดภัยและชนิดที่ไม่ปลอดภัยtoTupleNtoTuple

toTupleวิธีการได้รับข้อมูลประเภทความยาวที่ใช้เวลาเช่นไม่มีข้อมูลประเภทที่มีความยาวที่รวบรวมเวลาดังนั้นชนิดกลับเป็นProductซึ่งเป็นมากเช่นงูหลามเป็นtupleแน่นอน (ชนิดที่ไม่แต่ละตำแหน่งและความยาวของประเภทไม่ได้)
ด้วยวิธีนี้จะแสดงเป็นข้อผิดพลาดรันไทม์เช่นประเภทไม่ตรงกันหรือIndexOutOfBoundException . (ดังนั้นรายการต่อทูเพิลที่สะดวกของ Python จึงไม่ใช่อาหารกลางวันฟรี)

ในทางกลับกันมันเป็นข้อมูลที่ผู้ใช้ให้มาซึ่งทำให้toTupleNเวลาคอมไพล์ปลอดภัย

implicit class EnrichedWithToTuple[A](elements: Seq[A]) {
  def toTuple: Product = elements.length match {
    case 2 => toTuple2
    case 3 => toTuple3
  }
  def toTuple2 = elements match {case Seq(a, b) => (a, b) }
  def toTuple3 = elements match {case Seq(a, b, c) => (a, b, c) }
}

val product = List(1, 2, 3).toTuple
product.productElement(5) //runtime IndexOutOfBoundException, Bad ! 

val tuple = List(1, 2, 3).toTuple3
tuple._5 //compiler error, Good!

คุณสามารถทำได้เช่นกัน

1. ผ่านการจับคู่รูปแบบ (สิ่งที่คุณไม่ต้องการ) หรือ

2. โดยการวนซ้ำรายการและใช้แต่ละองค์ประกอบทีละรายการ

   val xs: Seq[Any] = List(1:Int, 2.0:Double, "3":String)
   val t: (Int,Double,String) = xs.foldLeft((Tuple3[Int,Double,String] _).curried:Any)({
     case (f,x) => f.asInstanceOf[Any=>Any](x)
   }).asInstanceOf[(Int,Double,String)]
   

เท่าที่คุณมีประเภท:

val x: List[Int] = List(1, 2, 3)

def doSomething(a:Int *)

doSomething(x:_*)