`A =› List[B]` สามารถแปลงเป็น `List[A =› B]` ได้หรือไม่

ในมุมมองของฉัน ฉันขอให้คอมไพเลอร์ทำซ้ำอินพุตนั้น A บาง n ครั้ง (ขนาด Lists) และแก้ไขเป็นอินพุต

ปัญหาคือคุณไม่รู้ว่า n คืออะไร ลองพิจารณาตัวอย่างฟังก์ชันที่คืนค่ารายการตัวหารเฉพาะของตัวเลข:

def divisors(n: Int): List[Int] = ???

คุณคาดหวังว่า explode(divisors) จะเป็นอย่างไร? divisors สามารถส่งคืน List ขนาดใดก็ได้ ขึ้นอยู่กับอาร์กิวเมนต์ เมื่อใดก็ตามที่มีการเรียกใช้ในอนาคต แต่เมื่อคุณโทร explode มันจะต้องส่งคืน List ของขนาดคงที่ทันที

ด้วยประเภทคงที่ A ลายเซ็นในโค้ดของคุณสามารถเขียนได้ดังนี้:

type F[T] = List[T]
type G[T] = A => T

def nest[B]: F[G[B]] => G[F[B]]
def explode[B]: G[F[B]] => F[G[B]]

nest และ explode ชวนให้นึกถึงการดำเนินการ sequence มันใช้ได้กับ nest เพราะเป็นไปได้ที่จะเขียนอินสแตนซ์ Traverse สำหรับ List แต่ ไม่สามารถเขียนอินสแตนซ์ Traverse สำหรับฟังก์ชัน A => T ได้ นี่คือคำถามที่เทียบเท่าสำหรับ Haskell ที่ให้ข้อมูลเชิงลึกมากขึ้น

หากคุณต้องการใช้งานบางอย่างที่ตรงตามลายเซ็น คุณสามารถดำเนินการดังนี้:

def explode[A, B](f: A => List[B]): List[A => B] = {
  Nil
}

def explode[A, B](f: A => List[B]): List[A => B] = {
  List(f.andThen(_.head))
}

แต่ฉันเดาว่าคุณต้องการบางสิ่งที่แตกต่างความหมาย:

ทำซ้ำอินพุต A n ครั้ง (ขนาดรายการ) และแก้ไขเป็นอินพุต

ในกรณีนั้นมีปัญหา. ผลลัพธ์ของ f ในกรณีทั่วไป ขึ้นอยู่กับอินพุต A อาจเป็น Nil รายการที่มีขนาดจำกัด หรือรายการที่ไม่มีที่สิ้นสุด

สิ่งที่คุณสามารถทำได้มีเพียงบางอย่างเช่น:

def explode[A, B](f: A => List[B]): A => List[A => B] = {
  f.andThen(_.map(b => (_: A) => b)
}