Декартова произведения и карте в Scala

это таким образом: разверните набор наборов строк в декартово произведение в Scala

идея вы хотите взять:

val sets = Set(Set("a","b","c"), Set("1","2"), Set("S","T"))

и вернуться обратно:

Set("a&1&S", "a&1&T", "a&2&S", ..., "c&2&T")

общее решение имеет вид:

def combine[A](f:(A, A) => A)(xs:Iterable[Iterable[A]]) =
    xs.reduceLeft { (x, y) => x.view.flatMap {a => y.map(f(a, _)) } }

используется следующим образом:

val expanded = combine{(x:String, y:String) => x + "&" + y}(sets).toSet

теоретически должен быть способ ввода типа Set[Set[A]] и Set[B]. То есть, чтобы преобразовать тип при объединении элементы.

примером использования было бы взять наборы строк (как указано выше) и вывести длины их конкатенации. The

6
cartesian-product scala

2 ответов

если вы действительно хотите, чтобы ваша функция сумматора для выполнения отображения, вы можете использовать fold, а как Крэг указал вы должны будете предоставить семян значение:

def combine[A, B](f: B => A => B, zero: B)(xs: Iterable[Iterable[A]]) =         
    xs.foldLeft(Iterable(zero)) { 
       (x, y) => x.view flatMap { y map f(_) } 
    }

тот факт, что вам нужно такое начальное значение, следует из типа функции combiner/mapper (B, A) => B (или, как функция Карри, B => A => B). Ясно, чтобы карта первая A вы сталкиваетесь, вам нужно будет предоставить B.

вы можете сделать это несколько проще для абонентов используя Zero тип класса:

trait Zero[T] {
   def zero: T
}
object Zero {
   implicit object IntHasZero extends Zero[Int] {
      val zero = 0
   }
   // ... etc ...
}

тут combine метод можно определить как:

def combine[A, B : Zero](f: B => A => B)(xs: Iterable[Iterable[A]]) =         
    xs.foldLeft(Iterable(implicitly[Zero[B]].zero)) { 
       (x, y) => x.view flatMap { y map f(_) }
    }

использование:

combine((b: Int) => (a: String) => b + a.length)(sets)

Scalaz предоставляет Zero тип класса, наряду с большим количеством других лакомств для функционального программирования.

9

проблема, с которой вы сталкиваетесь, заключается в том, что reduce(Left|Right) принимает функцию (A, A) => A, которая не позволяет вам изменять тип. Вы хотите что-то больше похожее на foldLeft, который принимает (B, A) ⇒ B, позволяя вам накапливать выход другого типа. однако складки нуждаются в начальном значении, которое не может быть пустой коллекцией здесь. Вам нужно будет разделить xs на голову и хвост, сопоставить голову iterable, чтобы быть Iterable[B], а затем вызвать foldLeft с отображенной головой, хвостом и некоторыми функция (B, A) => B. Это кажется больше проблем, чем стоит, поэтому я бы просто сделал все отображение спереди.

def combine[A, B](f: (B, B) => B)(g: (A) => B)(xs:Iterable[Iterable[A]]) =
  xs.map(_.map(g)).reduceLeft { (x, y) => x.view.flatMap {a => y.map(f(a, _)) } }
val sets = Set(Set(1, 2, 3), Set(3, 4), Set(5, 6, 7))
val expanded = combine{(x: String, y: String) => x + "&" + y}{(i: Int) => i.toString}(sets).toSet
7