I'd like to build the following list of tuples:
List(("a", 1), ("a", 2), ("a", 3), ("a", 4))
from two components:
"a"
List(1,2,3,4)
Known workarounds include:
List(1,2,3,4) zip Stream.continually("a") map { _.swap }
List(1,2,3,4).zipAll("a", "for missing values", "a")
List(1,2,3,4).map(("a",_))
However, I believe there is a better solution than these workarounds.
What's your definition of "better"?
Here is some possible solution:
scala> (List.fill(4)("a"), List(1, 2, 3, 4)).invert
res0: List[(String, Int)] = List((a,1), (a,2), (a,3), (a,4))
scala> List(1, 2, 3, 4).map{ ("a", _) }
res1: List[(String, Int)] = List((a,1), (a,2), (a,3), (a,4))
Just tried on a Scala worksheet:
List(1,2,3,4) map (v => ("a", v)) //> res0: List[(String, Int)] = List((a,1), (a,2), (a,3), (a,4))
What's wrong with it?
AFAIK there is no direct implementation of an inverted zip method in the standard Scala collection library.
However, if you take a look at the implementation of zip, which List takes from IterableLike, you can easily define your own zipInvert extension method:
import language.higherKinds
import collection.GenIterable
import collection.generic.CanBuildFrom
implicit class ZipInvert[A,CC[X] <: GenIterable[X]](coll: CC[A]) {
def zipInvert[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[CC[A], (B, A1), That]): That = {
val b = bf(coll)
val these = coll.iterator
val those = that.iterator
while (these.hasNext && those.hasNext)
b += ((those.next, these.next))
b.result
}
}
val numberList = List.range(1,5)
numberList zipInvert Stream.continually("a")
Paste this into the REPL to execute it or paste it in a file and execute it with scala -i:
scala -i ZipInvert.scala
Loading ZipInvert.scala...
import language.higherKinds
import collection.GenIterable
import collection.generic.CanBuildFrom
defined class ZipInvert
numberList: List[Int] = List(1, 2, 3, 4)
res0: List[(String, Int)] = List((a,1), (a,2), (a,3), (a,4))
...
The example above is compiled with Scala 2.10.4.
If you want to have no intermediate collection at all, e.g. to avoid further memory overhead, use the List companion object:
$ scala
Welcome to Scala version 2.10.4 (OpenJDK 64-Bit Server VM, Java 1.7.0_51).
Type in expressions to have them evaluated.
Type :help for more information.
scala> List.tabulate(4)(index => ("a",index+1))
res0: List[(String, Int)] = List((a,1), (a,2), (a,3), (a,4))
scala>
Related
Suppose I have a list of numbers and list of functions:
val xs: List[Int] = List(1, 2, 3)
val fs: List[Int => Int] = List(f1, f2, f3)
Now I would like to use an Applicative to apply f1 to 1, f2 to 2, etc.
val ys: List[Int] = xs <*> fs // expect List(f1(1), f2(2), f3(3))
How can I do it with Scalaz ?
pure for zip lists repeats the value forever, so it's not possible to define a zippy applicative instance for Scala's List (or for anything like lists). Scalaz does provide a Zip tag for Stream and the appropriate zippy applicative instance, but as far as I know it's still pretty broken. For example, this won't work (but should):
import scalaz._, Scalaz._
val xs = Tags.Zip(Stream(1, 2, 3))
val fs = Tags.Zip(Stream[Int => Int](_ + 3, _ + 2, _ + 1))
xs <*> fs
You can use the applicative instance directly (as in the other answer), but it's nice to have the syntax, and it's not too hard to write a "real" (i.e. not tagged) wrapper. Here's the workaround I've used, for example:
case class ZipList[A](s: Stream[A])
import scalaz._, Scalaz._, Isomorphism._
implicit val zipListApplicative: Applicative[ZipList] =
new IsomorphismApplicative[ZipList, ({ type L[x] = Stream[x] ## Tags.Zip })#L] {
val iso =
new IsoFunctorTemplate[ZipList, ({ type L[x] = Stream[x] ## Tags.Zip })#L] {
def to[A](fa: ZipList[A]) = Tags.Zip(fa.s)
def from[A](ga: Stream[A] ## Tags.Zip) = ZipList(Tag.unwrap(ga))
}
val G = streamZipApplicative
}
And then:
scala> val xs = ZipList(Stream(1, 2, 3))
xs: ZipList[Int] = ZipList(Stream(1, ?))
scala> val fs = ZipList(Stream[Int => Int](_ + 10, _ + 11, _ + 12))
fs: ZipList[Int => Int] = ZipList(Stream(<function1>, ?))
scala> xs <*> fs
res0: ZipList[Int] = ZipList(Stream(11, ?))
scala> res0.s.toList
res1: List[Int] = List(11, 13, 15)
For what it's worth, it looks like this has been broken for at least a couple of years.
I see a solution with streamZipApplicative :
import scalaz.std.stream._
import scalaz.Tags
val xs: List[Int] = List(1, 2, 3)
val fs: List[Int => Int] = List(f1, f2, f3)
val zippedLists = streamZipApplicative.ap(Tags.Zip(xs.toStream)) (Tags.Zip(fs.toStream))
val result = Tag.unwrap(zippedLists).toList
Learning Scalaz spends a few paragraphs on this topic in their introduction to Applicatives. They quote LYAHFGG:
However, [(+3),(2)] <> [1,2] could also work in such a way that the first function in the left list gets applied to the first value in the right one, the second function gets applied to the second value, and so on. That would result in a list with two values, namely [4,4]. You could look at it as [1 + 3, 2 * 2].
But then adds:
This can be done in Scalaz, but not easily.
The "not easily" part uses streamZipApplicative like in #n1r3's answer:
scala> streamZipApplicative.ap(Tags.Zip(Stream(1, 2)))(Tags.Zip(Stream({(_: Int) + 3}, {(_: Int) * 2})))
res32: scala.collection.immutable.Stream[Int] with Object{type Tag = scalaz.Tags.Zip} = Stream(4, ?)
scala> res32.toList
res33: List[Int] = List(4, 4)
The "not easily" is the part that bothers me. I'd like to borrow from #Travis Brown fantastic answer. He is comparing the use of monads and applicatives (i.e. why use applicatives when you have a monad?):
Second (and relatedly), it's just a solid development practice to use the least powerful abstraction that will get the job done.
So, I would say that until a framework provides an applicative that works like your first use-case:
val ys: List[Int] = xs <*> fs
To use zip and map here instead:
xs.zip(fs).map(p=>p._2.apply(p._1))
To me, this code is much clearer and simpler than the alternatives in scalaz. This is the least powerful abstraction that gets the job done.
Since searching for :+ doesn't yield any results (thanks google!) I couldn't find any answer to my question:
Why is:
a :+ b
resulting in
List[Any]
if both 'a' and 'b' are of type
List[Int]
try it out yourself, following won't compile (Scala 2.11.6, Idea14):
object AAA extends App {
val a: List[Int] = List[Int]()
val b: List[Int] = List[Int]()
val x: List[Int] = a :+ b
}
thx in advance
:+ appends a single element to a List. So you are appending a List[Int] to a List[Int], resulting in something like (if a and b are both set to List(1, 2)):
List(1, 2, List(1, 2))
Scala calculates the most common type between the element type (Int) and the thing you append (List[Int]), which is Any.
You probably wanted to concatenate two lists:
val x: List[Int] = a ++ b
I am looking for a nice way to remove first N elements which are equal from the ordered list, e.g.
List(1,1,1,2,3,3)
should return
removeSame(list) -> (1,1,1)
Is there a nice way to do it, rather than remove the head of the list and then use takeWhile on the remainder, and finally using dropwhile? I can think of simple non-functional solution but I was wondering whether any functional one also exists
The functional way to avoid the duplication of takeWhile and dropWhile to get a prefix and remainder is using span, i.e.
scala> val list = List(1,1,1,2,3,3)
list: List[Int] = List(1, 1, 1, 2, 3, 3)
scala> val (prefix, rest) = list span (_ == list.head)
prefix: List[Int] = List(1, 1, 1)
rest: List[Int] = List(2, 3, 3)
Is this what you look for?
scala> val l = List(1,1,1,2,3,3)
l: List[Int] = List(1, 1, 1, 2, 3, 3)
scala> l.takeWhile(_ == l.head)
res6: List[Int] = List(1, 1, 1)
scala> val l = List()
l: List[Nothing] = List()
scala> l.takeWhile(_ == l.head)
res7: List[Nothing] = List()
Not the best way of doing it, but this also works:
def removeSame(l: List) = if( !l.isEmpty) l.groupBy( x => x)(l.head) else List()
Is there any way to efficiently do this, perhaps through toBuffer or to methods? My real problem is I'm building a List off a parser, as follows:
lazy val nodes: Parser[List[Node]] = phrase(( nodeA | nodeB | nodeC).*)
But after building it, I want it to be a buffer instead - I'm just not sure how to build a buffer straight from the parser.
to indeed does the trick, and it is pretty trivial to use:
scala> val l = List(1,2,3)
l: List[Int] = List(1, 2, 3)
scala> l.to[ListBuffer]
res1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
Works in scala 2.10.x
For scala 2.9.x, you can do:
scala> ListBuffer.empty ++= l
res1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
I have 4 elements:List[List[Object]] (Objects are different in each element) that I want to zip so that I can have a List[List[obj1],List[obj2],List[obj3],List[obj4]]
I tried to zip them and I obtained a nested list that I can't apply flatten to because it says: no implicit argument matching parameter type.
How can I solve this? should I try another way or is there any way to make the flatten work?
I'm kinda new to scala so it may be a dumb question :D
Thanks in advance!
clau
For One Nested List:
flatten will do:
scala> List(List(1), List(2), List(3)).flatten
res4: List[Int] = List(1, 2, 3)
scala> List(List(List(1)), List(List(2)), List(List(3))).flatten
res5: List[List[Int]] = List(List(1), List(2), List(3))
For multiple Nested Lists then you can:
def flatten(ls: List[Any]): List[Any] = ls flatMap {
case i: List[_] => flatten(i)
case e => List(e)
}
val k = List(1, List(2, 3), List(List(List(List(4)), List(5)), List(6, 7)), 8)
flatten(k)
It prints List[Any] = List(1, 2, 3, 4, 5, 6, 7, 8)
Before Scala 2.9
From the error you pasted, it looks like you're trying to call the flatten instance method of the nested list itself. That requires an implicit conversion to make something of type Iterable out of whatever types the List contains. In your case, it looks like the compiler can't find one.
Use flatten from the List singleton object, which doesn't require that implicit parameter:
scala> val foo = List(List(1), List("a"), List(2.3))
foo: List[List[Any]] = List(List(1), List(a), List(2.3))
scala> List.flatten(foo)
res1: List[Any] = List(1, a, 2.3)
After Scala 2.9
Just use foo.flatten.
The question is very vague. You should plain paste what you have, instead of trying to describe it. It would make everyone's (including your's) life much easier.
The code below is one example based on an assumption of what you have.
scala> List(List(1))
res0: List[List[Int]] = List(List(1))
scala> List(List(2))
res1: List[List[Int]] = List(List(2))
scala> List(List(3))
res2: List[List[Int]] = List(List(3))
scala> List(List(4))
res3: List[List[Int]] = List(List(4))
scala> res0 ::: res1 ::: res2 ::: res3
res4: List[List[Int]] = List(List(1), List(2), List(3), List(4))
In scala 2.10.2
scala> val foo = List(List(1), List("a"), List(2.3))
foo: List[List[Any]] = List(List(1), List(a), List(2.3))
scala> foo.flatten
res0: List[Any] = List(1, 2, a, 2.3)
working fine but
if you run like
scala> val foo = List(List(1,2), 2, List(2.3))
foo: List[Any] = List(List(1, 2), 2, List(2.3))
scala> foo.flatten
<console>:9: error: No implicit view available from Any => scala.collection.GenTraversableOnce[B].
foo.flatten
for that i write function
scala> def flat(ls: List[Any]): List[Any]= ls flatten {
| case t: List[Any] => flat(t)
| case c => List(c)
| }
flat: (ls: List[Any])List[Any]
scala> flat(List(List(1,2),2,List(2.3)))
res2: List[Any] = List(1, 2, 2, 2.3)
It helps if we have an example. Your code should look something like:
val f = List(1, 2)
val s = List(3, 4)
val top = List(f, s)
List.flatten(top) // returns List(1, 2, 3, 4)
You can only zip two lists at a time with list1 zip list2, and the type signature for the return values is List[(A,B)] not List[List[obj1],List[obj2],List[obj3],List[obj4]]
Consider List.concat, for instance
List.concat(List(1), List(2,22), List(3)) // delivers List(1, 2, 22, 3)