jozic / scalax-collection

A small library of extension methods for standard scala collections library

Version Matrix

scalax-collection Build Status Coverage Status

A small library of extension methods for standard scala collections library. Published to maven central.

2.10 2.11 2.12 2.13
Maven Central Maven Central Maven Central Maven Central

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>