JarCastingscalax-collection 
A small library of extension methods for standard scala collections library. Published to maven central.
| 2.10 | 2.11 | 2.12 | 2.13 |
|---|---|---|---|
 |
 |
 |
 |
Collection Examples
An import needed for examples to work:
import com.daodecode.scalax.collection.extensions._
distinctBy
preserving first duplicate
val xs = List(1 -> "one", 1 -> "ten", 2 -> "two", 2 -> "twenty").distinctBy(_._1)
// xs: List[(Int, String)] = List((1, "one"), (2, "two"))
NOTE: Since Scala 2.13 this method is available in standard library
distinctByUsing
or preserving any duplicate you want
val xs = List(1 -> "one", 1 -> "ten", 2 -> "two", 2 -> "twenty").distinctByUsing(_._1, takeFirst = _._2.length > _._2.length)
// xs: List[(Int, String)] = List((1, "ten"), (2, "twenty"))
NOTE: Before 0.3.0 this method was named distinctBy
foldLeftWhile/foldRightWhile
val xs = Iterable(List(1,2,3), List(4,5), List(6,7,8,9)).foldLeftWhile(List.empty[Int])(_.size < 4){ case (acc, l) => acc ++ l }
// xs: List[Int] = List(1, 2, 3, 4, 5)
toCompleteMap
since Scala 2.13 can be seen as equivalent to groupMap(_._1)(_._2)
val cm = List(1 -> "1", 2 -> "2", 1 -> "11").toCompleteMap
// cm: Map[Int, List[String]] = Map(1 -> List("1", "11"), 2 -> List("2"))
mapToMap
can be seen as more efficient replacement for map().toMap combination
val m = List("1" -> "one", "2" -> "two").mapToMap { case (i, s) => i.toInt -> s }
// m: Map[Int, String] = Map(1 -> "one", 2 -> "two")
toMapWithKey
since Scala 2.13 can be seen as equivalent to groupMapReduce(f)(identity)((b,_) => b)
val m = List("1", "2", "1").toMapWithKey(_.toInt)
// m: Map[Int, String] = Map(1 -> "1", 2 -> "2")
toMapWithValue
since Scala 2.13 can be seen as equivalent to groupMapReduce(identity)(f)((b,_) => b)
val m = List("1", "2", "1").toMapWithValue(_.toInt)
// m: Map[String, Int] = Map("1" -> 1, "2" -> 2)
withFrequency
since Scala 2.13 can be seen as equivalent to groupMapReduce(identity)(_ => 1)(_ + _)
val fm = List("a", "b", "c", "a", "b", "d").withFrequency
// fm: Map[String, Int] = Map("a" -> 2, "b" -> 2, "c" -> 1, "d" -> 1)
withFrequencyBy
since Scala 2.13 can be seen as equivalent to groupMapReduce(f)(_ => 1)(_ + _)
val fm = List("ab", "bc", "cd", "ab", "bc", "de").withFrequencyBy(_.head)
// fm: Map[Char, Int] = Map('a' -> 2, 'b' -> 2, 'c' -> 1, 'd' -> 1)
mergedWith
Merges two maps using provided function to merge values for duplicate keys
val merged = Map("1" -> 1, "2" -> 2).mergedWith(Map("1" -> 1, "2" -> 2))(_ + _)
// merged: Map[String, Int] = Map("1" -> 2, "2" -> 4)
minOption/minOptionBy
Finds the smallest element wrapped in Option or None if iterable is empty
val m1 = List.empty[Int].minOption
// m1: Option[Int] = None
val m2 = List(1,2,1).minOptionBy(_ * -1)
// m2: Option[Int] = Some(value = 2)
NOTE: Since Scala 2.13 this is available in standard library
maxOption/maxOptionBy
Finds the largest element wrapped in Option or None if iterable is empty
val m1 = List.empty[Int].maxOption
// m1: Option[Int] = None
val m2 = List(1,2,1).maxOptionBy(_ * -1)
// m2: Option[Int] = Some(value = 1)
NOTE: Since Scala 2.13 this is available in standard library
unzip4/unzip5/unzip6
Similar to unzip and unzip3 from standard library, but for tuples of higher arity (up to 6)
val (ints, strings, chars, doubles) =
Iterable(
(1, "one", '1', 1d),
(2, "two", '2', 2d),
(3, "three", '3', 3d),
(4, "four", '4', 4d)
).unzip4
// ints: Iterable[Int] = List(1, 2, 3, 4)
// strings: Iterable[String] = List("one", "two", "three", "four")
// chars: Iterable[Char] = List('1', '2', '3', '4')
// doubles: Iterable[Double] = List(1.0, 2.0, 3.0, 4.0)
Strings Examples
An import needed for examples to work:
import com.daodecode.scalax._
NonEmptyString
NonEmptyString(null)
// res0: Option[String] = None
NonEmptyString("")
// res1: Option[String] = None
NonEmptyString(" a ")
// res2: Option[String] = Some(value = " a ")
(null: String) match {
case NonEmptyString(_) => "boo"
case _ => "works!"
}
// res3: String = "works!"
"" match {
case NonEmptyString(_) => "boo"
case _ => "works!"
}
// res4: String = "works!"
"works!" match {
case NonEmptyString(s) => s
case _ => "boo"
}
// res5: String = "works!"
NonBlankString
NonBlankString(null)
// res6: Option[String] = None
NonBlankString("")
// res7: Option[String] = None
NonBlankString(" \n \r \t ")
// res8: Option[String] = None
NonBlankString(" a ")
// res9: Option[String] = Some(value = " a ")
(null: String) match {
case NonBlankString(_) => "boo"
case _ => "works!"
}
// res10: String = "works!"
"" match {
case NonBlankString(_) => "boo"
case _ => "works!"
}
// res11: String = "works!"
" \t " match {
case NonBlankString(_) => "boo"
case _ => "works!"
}
// res12: String = "works!"
"works!" match {
case NonBlankString(s) => s
case _ => "boo"
}
// res13: String = "works!"
NonBlankTrimmedString
NonBlankTrimmedString(null)
// res14: Option[String] = None
NonBlankTrimmedString("")
// res15: Option[String] = None
NonBlankTrimmedString(" \n \r \t ")
// res16: Option[String] = None
NonBlankTrimmedString(" a ")
// res17: Option[String] = Some(value = "a")
(null: String) match {
case NonBlankTrimmedString(_) => "boo"
case _ => "works!"
}
// res18: String = "works!"
"" match {
case NonBlankTrimmedString(_) => "boo"
case _ => "works!"
}
// res19: String = "works!"
" \t " match {
case NonBlankTrimmedString(_) => "boo"
case _ => "works!"
}
// res20: String = "works!"
" works!\n " match {
case NonBlankTrimmedString(s) => s
case _ => "boo"
}
// res21: String = "works!"
Latest stable release
sbt
libraryDependencies += "com.daodecode" %% "scalax-collection" % "0.3.2"
maven
set <scala.binary.version> property to scala version you need, like
<properties>
<scala.binary.version>2.13</scala.binary.version>
</properties>
and then in dependencies add
<dependency>
<groupId>com.daodecode</groupId>
<artifactId>scalax-collection_${scala.binary.version}</artifactId>
<version>0.3.2</version>
</dependency>