Dlaczego lista jest półgrupą, ale w Seq nie jest?

Question

Jestem dość nowy scalaz i próbuję dowiedzieć się, dlaczego następujący kod działa:

import scalaz._ 
import Scalaz._ 
scala> Map[String,List[String]]() |+| Map[String,List[String]]() 
res3: scala.collection.immutable.Map[String,List[String]] = Map() 

ale to nie ...

import scalaz._ 
import Scalaz._ 
scala> Map[String,Seq[String]]() |+| Map[String,Seq[String]]() 
<console>:14: error: value |+| is not a member of  scala.collection.immutable.Map[String,Seq[String]] 
      Map[String,Seq[String]]() |+| Map[String,Seq[String]]() 

widzę Mapa niejawny dla Półgrupa, ale nie widzę tej dla Listy lub Sekw.

kilka pytań:

1. Gdzie jest niejawny dla ListSemigroup?
2. Dlaczego nie ma jednego dla Seq?

Answer 1

Tak, w Scalaz 7 jest implicit List to Monoid function, który daje z powrotem Monoid[List[A]]. Monoid rozszerza SemiGroup, więc mamy listę objętych.

Seq nie otrzymuje tego specjalnego traktowania. Nie ma żadnej niejawnej konwersji z Seq do lub Semigroup. Jest implicit IndexedSeq to Monoid, ale to nam nie pomaga.

Dlaczego nie ma jednego dla Seq? Nie wiem Być może Seq narusza pewne prawa monoidżetów/półgrup, więc nie ma konwersji. Wydaje się, że w Scalaz 6 były problemy z SEQ więc usunęliśmy kilka funkcji: https://groups.google.com/forum/?fromgroups=#!searchin/scalaz/Seq/scalaz/Deaec1H11W4/gYFSquXjTzYJ

UPDATE

patrząc na doc scala staje się bardziej oczywiste, dlaczego ludzie scalaz poszedł tą drogą. List dziedziczy LinearSeq, który dziedziczy Seq. IndexedSeq dziedziczy Seq. Jeśli mieliby dostarczyć półgrupę dla Seq, mogłaby ona zastąpić każdą inną półgrupę na IndexedSeq lub LinearSeq i luźne zalety wydajności między tymi dwoma. Jeśli spojrzeć na podpisami scalaz dla append widać, że korzystają oni z tych różnic wydajności:

https://github.com/scalaz/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/std/List.scala

implicit def listMonoid[A]: Monoid[List[A]] = new Monoid[List[A]] { 
    def append(f1: List[A], f2: => List[A]) = f1 ::: f2 
    def zero: List[A] = Nil 
    } 

https://github.com/scalaz/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/std/IndexedSeq.scala

implicit def ixSqMonoid[A]: Monoid[IxSq[A]] = new Monoid[IxSq[A]] { 
    def append(f1: IxSq[A], f2: => IxSq[A]) = f1 ++ f2 
    def zero: IxSq[A] = empty 
    } 

jeśli będziemy kopać głębiej, widzimy, że sekwencyjny implementuje tylko ++, który ma gorszą wydajność na listach niż ::: dla operacji dołączania. Tak więc, aby odpowiedzieć na twoje drugie pytanie, wydajność. Jeśli skalaz zaimplementował półgrupę dla Seq, najprawdopodobniej doprowadziłoby to do niejednoznacznej wydajności, ponieważ byłbyś w stanie zoptymalizować tylko pod kątem indeksowania. Iterable ma ten sam problem.