Pimpathon Documentation

tupled (A ⇒ B ⇒ C) GH

(A ⇒ B ⇒ C) ⇒ ((A, B)) ⇒ C

Convert curried function to a tupled one

between Random GH

Random ⇒ (Int, Int) ⇒ Int

Generate a random number between two others

Random.between(0, 10)

promote Ordering[A] GH

Ordering[A] ⇒ A* ⇒ Ordering[A]

Promote occurences of the provided values when sorting

List(10, 7, 5, 2, 7).sorted(Ordering.Int.promote(5, 7))

List(5, 7, 7, 2, 10)

demote Ordering[A] GH

Ordering[A] ⇒ A* ⇒ Ordering[A]

Demote occurences of the provided values when sorting

List(10, 7, 5, 2, 7).sorted(Ordering.Int.demote(5, 7))

List(2, 10, 5, 7, 7)

tap Either[L, R] GH

Either[L, R] ⇒ (L ⇒ Discarded, R ⇒ Discarded) ⇒ Either[L, R]

Perform one action or another

    Left(1).tap(l ⇒ print("left: " + l), r ⇒ print("right: " + r))

Prints "left: 1"

Right(true).tap(l ⇒ print("left: " + l), r ⇒ print("right: " + r))

Prints "right: true"

tapLeft Either[L, R] GH

Either[L, R] ⇒ (L ⇒ Discarded) ⇒ Either[L, R]

Perform action if Left

    Left(1).tapLeft(l ⇒ print("left: " + l))

Prints "left: 1"

Right(true).tapLeft(l ⇒ print("left: " + l))

Does nothing

tapRight Either[L, R] GH

Either[L, R] ⇒ (R ⇒ Discarded) ⇒ Either[L, R]

Perform action if Right

    Left(1).tap(r ⇒ print("right: " + r))

Does nothing

Right(true).tap(r ⇒ print("right: " + r))

Prints "right: true"

addTo Either[L, R] GH

Either[L, R] ⇒ (Growable[L], Growable[R]) ⇒ Either[L, R]

Adds values into growables

     Left(1).addTo(ints, strings)

ints += 1

Right("foo").addTo(ints, strings)

strings += "foo"

removeFrom Either[L, R] GH

Either[L, R] ⇒ (Shrinkable[L], Shrinkable[R]) ⇒ Either[L, R]

Removes values from a shrinkables

     Left(1).removeFrom(ints, strings)

ints -= 1

Right("foo").removeFrom(ints, strings)

strings -= "foo"

getOrThrow Map[K, V] GH

Map[K, V] ⇒ (K, String) ⇒ V

Retrieve value associated with key or throw exception with message

Map(1 → 2).getOrThrow(1, "Alas, no 1")

Map(2 → 3).getOrThrow(1, "Alas, no 1")

throw new IllegalArgumentException("Alas no 1")

getOrThrow Map[K, V] GH

Map[K, V] ⇒ (K, ⇒ Exception) ⇒ V

Retrieve value associated with key or throw exception

Map(1 → 2).getOrThrow(1, new Exception("No such element"))

Map(2 → 3).getOrThrow(1, new Exception("No such element"))

throw new Exception("No such element")

mapKeysEagerly Map[K, V] GH

Map[K, V] ⇒ (K ⇒ C) ⇒ Map[C, V]

Eagerly applies a function to each key

Map(1 → 2, 2 → 3).mapKeysEagerly(_ * 10)

Map(10 → 2, 20 → 3)

mapValuesEagerly Map[K, V] GH

Map[K, V] ⇒ (V ⇒ W) ⇒ Map[K, W]

Eagerly applies a function to each value

Map(1 → 2, 2 → 3).mapValuesEagerly(_ * 10)

Map(1 → 20, 2 → 30)

mapEntries Map[K, V] GH

Map[K, V] ⇒ (K ⇒ V ⇒ (C, W)) ⇒ Map[C, W]

Applies a function to each entry, result must be a Tuple2

Map(1 → 2, 2 → 3).mapEntries(k ⇒ v ⇒ (k * 10, v + 0.5))

Map(10 → 2.5, 20 → 3.5)

seqMapKeys Map[K, V] GH

Map[K, V] ⇒ (K ⇒ Option[C]) ⇒ Option[Map[C, V]]

Eagerly applies a function to each key, produces a Map if it never equals None

Map(2 → 4, 4 → 6).seqMapKeys(k ⇒ (k % 2 == 0).option(k / 2)))

Some(Map(1 → 4, 2 → 6))

       Map(1 → 3).seqMapKeys(k ⇒ (k % 2 == 0).option(k / 2)))

None

seqMapValues Map[K, V] GH

Map[K, V] ⇒ (V ⇒ Option[W]) ⇒ Option[Map[K, W]]

Eagerly applies a function to each value, produces a Map if it never equals None

Map(2 → 4, 4 → 6).seqMapValues(v ⇒ (v % 2 == 0).option(v / 2)))

Some(Map(2 → 2, 4 → 3))

       Map(1 → 3).seqMapValues(v ⇒ (v % 2 == 0).option(v / 2)))

None

seqMapEntries Map[K, V] GH

Map[K, V] ⇒ (K ⇒ V ⇒ Option[(C, W)]) ⇒ Option[Map[C, W]]

Applies a function to each entry, produces a Map if it never equals None

Map(2 → 4, 4 → 6).seqMapEntries(k ⇒ v => (k % 2 == 0).option((k / 2) -> (v / 2)))

Some(Map(1 → 2, 2 → 3))

       Map(1 → 3).seqMapEntries(k ⇒ v => (k % 2 == 0).option((k / 2) -> (v / 2)))

None

collectKeys Map[K, V] GH

Map[K, V] ⇒ PartialFunction[K, C] ⇒ Map[C, V]

Applies a partial function to each key

Map(1 → 2, 2 → 3).collectKeys { case 2 → 20 }

Map(20 → 3)

updateKeys Map[K, V] GH

Map[K, V] ⇒ PartialFunction[K, C] ⇒ Map[C, V]

Applies a partial function to each key

Map(1 → 2, 2 → 3).updateKeys { case 2 → 20 }

Map(20 → 3)

updateKeys Map[K, V] GH

Map[K, V] ⇒ (K ⇒ Option[C]) ⇒ Map[C, V]

Applies a function to each key, retains only Somes

Map(1 → 2, 2 → 3).updateKeys(k ⇒ if (k == 2) Some(20) else None)

Map(20 → 3)

updateValue Map[K, V] GH

Map[K, V] ⇒ (K, V ⇒ Option[V]) ⇒ Map[K, V]

Update or remove a single entry

Map(1 → 2, 2 → 3).updateValue(1, _ ⇒ None)

Map(2 → 3)

collectValues Map[K, V] GH

Map[K, V] ⇒ PartialFunction[V, W] ⇒ Map[K, W]

Applies a partial function to each value

Map(1 → 2, 2 → 3).collectValues { case 2 ⇒ 20 }

Map(1 → 20)

updateValues Map[K, V] GH

Map[K, V] ⇒ PartialFunction[V, W] ⇒ Map[K, W]

Applies a partial function to each value

Map(1 → 2, 2 → 3).updateValues { case 2 ⇒ 20 }

Map(1 → 20)

updateValues Map[K, V] GH

Map[K, V] ⇒ (V ⇒ Option[W]) ⇒ Map[K, W]

Applies a function to each value, retains only Somes

Map(1 → 2, 2 → 3).updateValues(v ⇒ if (v == 2) Some(20) else None)

Map(1 → 20)

keyExists Map[K, V] GH

Map[K, V] ⇒ Predicate[K] ⇒ Boolean

Determine if any key matches the predicate

Map(1 → 2).keyExists(_ > 1)

false

Map(2 → 3).keyExists(_ > 1)

true

valueExists Map[K, V] GH

Map[K, V] ⇒ Predicate[V] ⇒ Boolean

Determine if any value matches the predicate

Map(1 → 2).valueExists(_ > 2)

false

Map(2 → 3).valueExists(_ > 2)

true

filterValues Map[K, V] GH

Map[K, V] ⇒ Predicate[V] ⇒ Map[K, V]

Retain those values that match a predicate

Map(1 → 2, 2 → 3).filterValues(_ > 2)

Map(2 → 3)

filterValuesNot Map[K, V] GH

Map[K, V] ⇒ Predicate[V] ⇒ Map[K, V]

Discard those value that match a predicate

Map(1 → 2, 2 → 3).filterValuesNot(_ > 2)

Map(1 → 2)

filterKeysNot Map[K, V] GH

Map[K, V] ⇒ Predicate[K] ⇒ Map[K, V]

Discard those keys that match a predicate

Map(1 → 2, 2 → 3).filterKeysNot(_ > 1)

Map(1 → 2)

findValue Map[K, V] GH

Map[K, V] ⇒ Predicate[V] ⇒ Option[V]

Search for a value that matches a predicate

Map(1 → 2).findValue(_ > 2)

None

Map(2 → 3).findValue(_ > 2)

Some(3)

findKey Map[K, V] GH

Map[K, V] ⇒ Predicate[K] ⇒ Option[K]

Search for a key that matches a predicate

Map(1 → 2).findValue(_ > 1)

None

Map(2 → 3).findValue(_ > 1)

Some(2)

sorted Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[K] ⇒ SortedMap[K, V]

Sort map by keys

Map(1 → 2, 2 → 3).sorted(Ordering.Int.reverse)

SortedMap(2 → 3, 1 → 2)

reverse Map[K, V] GH

Map[K, V] ⇒ (Set[K] ⇒ K) ⇒ Map[V, K]

Reverse the keys & values, using the function to choose between keys

Map(1 → 2, 2 → 3, 3 → 3).reverse(_.min)

Map(2 → 1, 3 → 2)

reverseToMultiMap Map[K, V] GH

Map[K, V] ⇒ MultiMap[Set, V, K]

Reverse the keys & values, retaining all data

Map(1 → 2, 2 → 3, 3 → 3).reverseToMultiMap

Map(2 → Set(1), 3 → Set(2, 3))

containsAll Map[K, V] GH

Map[K, V] ⇒ Option[K] ⇒ Boolean

Determine if the map contains all the provided keys

Map(1 → 2).containsAll(None)

true

Map(1 → 2).containsAll(Some(10))

false

Map(1 → 2).containsAll(Some(1))

true

containsAll Map[K, V] GH

Map[K, V] ⇒ GTL[K] ⇒ Boolean

Determine if the map contains all the provided keys

Map(1 → 2).containsAll(Nil)

true

Map(1 → 2).containsAll(List(10))

false

Map(1 → 2).containsAll(List(1))

true

containsAny Map[K, V] GH

Map[K, V] ⇒ Option[K] ⇒ Boolean

Determine if the map contains any of the provided keys

Map(1 → 2).containsAny(None)

false

Map(1 → 2).containsAny(Some(10))

false

Map(1 → 2).containsAny(Some(1))

true

containsAny Map[K, V] GH

Map[K, V] ⇒ GTL[K] ⇒ Boolean

Determine if the map contains any of the provided keys

Map(1 → 2).containsAny(Nil)

true

Map(1 → 2).containsAny(List(10))

false

Map(1 → 2).containsAny(List(1))

true

containsEntry Map[K, V] GH

Map[K, V] ⇒ (K, V) ⇒ Boolean

Determine if the map contains the provided entry

Map(1 → 2).containsEntry(1, 2)

true

Map(1 → 2).containsEntry(1, 1)

false

containsEntry Map[K, V] GH

Map[K, V] ⇒ ((K, V)) ⇒ Boolean

Determine if the map contains the provided entry

Map(1 → 2).containsEntry((1, 2))

true

Map(1 → 2).containsEntry((1, 1))

false

get Map[K, V] GH

Map[K, V] ⇒ Option[K] ⇒ Option[V]

Lookup the provided key if Some

Map(1 → 2).get(None)

None

Map(1 → 2).get(Some(2))

None

Map(1 → 2).get(Some(1))

Some(2)

emptyTo Map[K, V] GH

Map[K, V] ⇒ Map[K, V] ⇒ Map[K, V]

Converts empty map to provided value, leaves other maps alone

Map(1 → 2).emptyTo(Map(2 → 3))

Map(1 → 2)

Map().emptyTo(Map(2 → 3))

Map(2 → 3)

uncons Map[K, V] GH

Map[K, V] ⇒ (A, Map[K, V] ⇒ A) ⇒ A

Convert to A depending on whether the map is empty or not

     Map().uncons("empty", m ⇒ "non-empty: " + m.size)

"empty"

Map(1 → 2).uncons("empty", m ⇒ "non-empty: " + m.size)

"non-empty: 1"

entryFor.minKey Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[K] ⇒ Option[(K, V)]

The entry with the minimum key

Map(1 → 2, 2 → 3).entryFor.minKey

Some((1, 2))

Map(1 → 2, 2 → 3).entryFor.minKey(Ordering.Int.reverse)

Some((2, 3))

entryFor.maxKey Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[K] ⇒ Option[(K, V)]

The entry with the maximum key

Map(1 → 2, 2 → 3).entryFor.maxKey

Some((2, 3))

Map(1 → 2, 2 → 3).entryFor.maxKey(Ordering.Int.reverse)

Some((1, 2))

entryFor.minValue Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[V] ⇒ Option[(K, V)]

The entry with the minimum value

Map(1 → 2, 2 → 3).entryFor.minValue

Some((1, 2))

Map(1 → 2, 2 → 3).entryFor.minValue(Ordering.Int.reverse)

Some((2, 3))

entryFor.maxValue Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[V] ⇒ Option[(K, V)]

The entry with the maximum value

Map(1 → 2, 2 → 3).entryFor.maxValue

Some((2, 3))

Map(1 → 2, 2 → 3).entryFor.maxValue(Ordering.Int.reverse)

Some((1, 2))

entryFor.matchingKey Map[K, V] GH

Map[K, V] ⇒ Predicate[K] ⇒ Option[(K, V)]

The entry whose key matches the predicate

Map(1 → 2, 2 → 3).entryFor.matchingKey(_ > 2)

Some((2, 3))

entryFor.matchingValue Map[K, V] GH

Map[K, V] ⇒ Predicate[V] ⇒ Option[(K, V)]

The entry whose value matches the predicate

Map(1 → 2, 2 → 3).entryFor.matchingValue(_ > 3)

Some((2, 3))

keyFor.minValue Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[V] ⇒ Option[K]

The key whose entry has the minimum value

Map(1 → 2, 2 → 3).keyFor.minValue

Some(1)

Map(1 → 2, 2 → 3).keyFor.minValue(Ordering.Int.reverse)

Some(2)

keyFor.maxValue Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[V] ⇒ Option[K]

The key whose entry has the maximum value

Map(1 → 2, 2 → 3).keyFor.maxValue

Some(2)

Map(1 → 2, 2 → 3).keyFor.maxValue(Ordering.Int.reverse)

Some(1)

valueFor.minKey Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[K] ⇒ Option[V]

The value whose entry has the minimum key

Map(1 → 2, 2 → 3).valueFor.minKey

Some(2)

Map(1 → 2, 2 → 3).valueFor.minKey(Ordering.Int.reverse)

Some(3)

valueFor.maxKey Map[K, V] GH

Map[K, V] ⇒ implicit Ordering[K] ⇒ Option[V]

The value whose entry has the maximum key

Map(1 → 2, 2 → 3).valueFor.maxKey

Some(3)

Map(1 → 2, 2 → 3).valueFor.maxKey(Ordering.Int.reverse)

Some(2)

andThenM Map[K, V] GH

Map[K, V] ⇒ Map[V, W] ⇒ Map[K, W]

Join the values of the map with the keys of another

Map(1 → 2, 2 → 3).andThenM(Map(2 → "two"))

Map(1 → "two")

composeM Map[K, V] GH

Map[K, V] ⇒ Map[C, K] ⇒ Map[C, V]

Join the keys of the map with the values of another

Map(1 → 2, 2 → 3).composeM(Map("two" → 2))

Map("two" → 3)

partitionKeysBy Map[K, V] GH

Map[K, V] ⇒ PartialFunction[K, C] ⇒ (Map[K, V], Map[C, V])

Applies a partial function to each key but retain the subset of the input where the function isn't defined

Map(1 → 2, 2 → 3).partitionKeysBy { case 2 ⇒ "two" }

(Map(1 → 2), Map("two" → 3))

partitionValuesBy Map[K, V] GH

Map[K, V] ⇒ PartialFunction[V, W] ⇒ (Map[K, V], Map[K, W])

Applies a partial function to each value but retain the subset of the input where the function isn't defined

Map(1 → 2, 2 → 3).partitionValuesBy { case 2 ⇒ "two" }

(Map(2 → 3), Map(1 → "two"))

partitionEntriesBy Map[K, V] GH

Map[K, V] ⇒ PartialFunction[(K, V), (C, W)] ⇒ (Map[K, V], Map[C, W])

Applies a partial function to each entry but retain the subset of the input where the function isn't defined

Map(1 → 2, 2 → 3).partitionValuesBy { case (1, 2) ⇒ ("one", "two") }

(Map(2 → 3), Map("one" → "two"))

calcIfNonEmpty Map[K, V] GH

Map[K, V] ⇒ (Map[K, V] ⇒ B) ⇒ Option[B]

Calculate result if non empty, None otherwise

Map(1 → 2, 2 → 3).calcIfNonEmpty(_.length)

Some(2)

Map().calcIfNonEmpty(_.length)

None

mutable Map[K, V] GH

Map[K, V] ⇒ mutable.Map[K, V]

Convert to mutable Map

toMutable Map[K, V] GH

Map[K, V] ⇒ mutable.Map[K, V]

Convert to mutable Map

contramapKeys EncodeJson[Map[K, V]] GH

EncodeJson[Map[K, V]] ⇒ (C ⇒ K) ⇒ EncodeJson[Map[C, V]]

Converts map keys before encoding

mapEncoder.contramapKeys(_.reverse).encodeJson(Map("foo" → "bar"))

{ "oof" → "bar" }

contramapValues EncodeJson[Map[K, V]] GH

EncodeJson[Map[K, V]] ⇒ (W ⇒ V) ⇒ EncodeJson[Map[K, W]]

Converts map values before encoding

mapEncoder.contramapValues(_.reverse).encodeJson(Map("foo" → "bar"))

{ "foo" → "rab" }

xmapKeys CodecJson[Map[K, V]] GH

CodecJson[Map[K, V]] ⇒ (K ⇒ C) ⇒ (C ⇒ K) ⇒ CodecJson[Map[C, V]]

Converts map keys before encoding & after decoding

xmapValues CodecJson[Map[K, V]] GH

CodecJson[Map[K, V]] ⇒ (V ⇒ W) ⇒ (W ⇒ V) ⇒ CodecJson[Map[K, W]]

Converts map values before encoding & after decoding

xmap Numeric[A] GH

Numeric[A] ⇒ (A ⇒ B, B ⇒ A) ⇒ Numeric[B]

Converts to operate on a new type

implicitly[Numeric[Int]].xmap[String](_.toString, Integer.parseInt).plus("2", "3")

"5"

toFailureNel Option[E] GH

Option[E] ⇒ (⇒ A) ⇒ ValidationNel[E, A]

Converts Some to FailureNel & None to Success

Some(1).toFailureNel("succeed")

Failure(NonEmptyList(1))

None.toFailureNel("succeed")

Success("succeed")

getOrThrow Option[A] GH

Option[A] ⇒ String ⇒ A

Return value or throw exception with message

None.getOrThrow("No potatoes!")

throws NoSuchElementException("No potatoes")

Some("Potatoes").getOrThrow("No potatoes")

"Potatoes"

getOrThrow Option[A] GH

Option[A] ⇒ (⇒ Exception) ⇒ A

Return value or throw exception

None.getOrThrow(new PotatoException("No potatoes!"))

throws PotatoException("No potatoes")

Some("Potatoes").getOrThrow(new PotatoException("No potatoes"))

"Potatoes"

invert Option[A] GH

Option[A] ⇒ A ⇒ Option[A]

Convert Some to None and vice versa

None.invert(456)

Some(456)

Some(123).invert(456)

None

toTry Option[A] GH

Option[A] ⇒ Try[A]

Convert Some to Success and None to Failure

None.toTry

Failure(new NoSuchElementException)

Some(123).toTry

Success(123)

tap Option[A] GH

Option[A] ⇒ (⇒ Discarded, A ⇒ Discarded) ⇒ Option[A]

Perform one action or another

None.tap(println("none"), i ⇒ println(s"some: $i"))

prints "none"

Some(123).tap(println("none"), i ⇒ println(s"some: $i"))

prints "some: 123"

tapNone Option[A] GH

Option[A] ⇒ (⇒ Discarded) ⇒ Option[A]

Perform action if None

None.tapNone(println("none"))

prints "none"

Some(123).tapNone(println("none"))

Does nothing

tapSome Option[A] GH

Option[A] ⇒ (A ⇒ Discarded) ⇒ Option[A]

Perform action if Some

None.tapSome(i ⇒ println(s"some: $i"))

Does nothing

Some(123).tapSome(i ⇒ println(s"some: $i"))

prints "some: 123"

amass Option[A] GH

Option[A] ⇒ PartialFunction[A, Option[B]] ⇒ Option[B]

Applies partial function if Some

     None amass { case 123 ⇒ Some(456) }

None

Some(321) amass { case 123 ⇒ Some(456) }

None

Some(123) amass { case 123 ⇒ Some(456) }

Some(456)

toSuccessNel Option[A] GH

Option[A] ⇒ (⇒ E) ⇒ ValidationNel[E, A]

Converts Some to Success & None to FailureNel

Some(1).toSuccessNel("fail")

Success(1)

None.toSuccessNel("fail")

Failure(NonEmptyList("fail"))

append NestedMap[K1, K2, V] GH

NestedMap[K1, K2, V] ⇒ (K1, K2, V) ⇒ NestedMap[K1, K2, V]

Append a value

Map(1 → Map(2 → 3)).append(1, 2, 4)

Map(1 → Map(2 → 4))

Map(1 → Map(2 → 3)).append(1, 3, 4)

Map(1 → Map(2 → 3, 3 → 4))

Map(1 → Map(2 → 3)).append(2, 3, 4)

Map(1 → Map(2 → 3), 2 → Map(3 → 4))

+ NestedMap[K1, K2, V] GH

NestedMap[K1, K2, V] ⇒ ((K1, K2, V)) ⇒ NestedMap[K1, K2, V]

Append a value

Map(1 → Map(2 → 3)) + ((1, 2, 4))

Map(1 → Map(2 → 4))

Map(1 → Map(2 → 3)) + ((1, 3, 4))

Map(1 → Map(2 → 3, 3 → 4))

Map(1 → Map(2 → 3)) + ((2, 3, 4))

Map(1 → Map(2 → 3), 2 → Map(3 → 4))

flipNesting NestedMap[K1, K2, V] GH

NestedMap[K1, K2, V] ⇒ NestedMap[K2, K1, V]

Flips the inner & outer keys

Map(1 → Map(2 → 3), 6 → Map(3 → 4, 4 → 5)).flipNesting

Map(2 → Map(1 → 3), 3 → Map(6 → 4), 4 → Map(6 → 5))

getOrEmpty NestedMap[K1, K2, V] GH

NestedMap[K1, K2, V] ⇒ K1 ⇒ Map[K2, V]

Retrive the values associated with a key or an empty collection

Map(1 → Map(2 → 3)).getOrEmpty(1)

Map(2 → 3)

Map(1 → Map(2 → 3)).getOrEmpty(2)

Map()

nestedMap.mapValuesEagerly NestedMap[K1, K2, V] GH

NestedMap[K1, K2, V] ⇒ (V ⇒ W) ⇒ NestedMap[K1, K2, W]

Eagerly applies a function to each value

Map(1 → Map(2 → 3)).nestedMap.mapValueEagerly(_ * 10)

Map(1 → Map(2 → 30))

nestedMap.mapKeysEagerly NestedMap[K1, K2, V] GH

NestedMap[K1, K2, V] ⇒ (K2 ⇒ C) ⇒ NestedMap[K1, C, V]

Eagerly applies a function to each inner key

Map(1 → Map(2 → 3)).nestedMap.mapKeysEagerly(_ * 10)

Map(1 → Map(20 → 3))

closeAfter OutputStream GH

OutputStream ⇒ (OutputStream ⇒ A) ⇒ A

Close after applying a function

attemptClose OutputStream GH

OutputStream ⇒ Try[Unit]

Close & catch exceptions

closeIf OutputStream GH

OutputStream ⇒ Boolean ⇒ OutputStream

Close if boolean is true

closeUnless OutputStream GH

OutputStream ⇒ Boolean ⇒ OutputStream

Close if boolean is false

drain OutputStream GH

OutputStream ⇒ (InputStream, Boolean, Boolean) ⇒ OutputStream

Drain all bytes from an InputStream, optionally closing each afterwards

<< OutputStream GH

OutputStream ⇒ InputStream ⇒ OutputStream

Drain all bytes from an InputStream

buffered OutputStream GH

OutputStream ⇒ BufferedOutputStream

Wrap in a BufferedOutputStream

gzip OutputStream GH

OutputStream ⇒ GZIPOutputStream

Wrap in a GZIPOutputStream

writeN OutputStream GH

OutputStream ⇒ (InputStream, Long) ⇒ OutputStream

Write n bytes into an InputStream & throw if unable to

writeUpToN OutputStream GH

OutputStream ⇒ (InputStream, Long) ⇒ Long

Write up to n bytes into an InputStream

asMap... NonEmptyList[V] GH

NonEmptyList[V] ⇒

asMultiMap... NonEmptyList[V] GH

NonEmptyList[V] ⇒

asInt Boolean GH

Boolean ⇒ Int

Converts to int

false.asInt

true.asInt

either.or Boolean GH

Boolean ⇒ R ⇒ L ⇒ Either[L, R]

Construct a Right if true, Left if false

false.either(1).or("foo")

Left("foo")

true.either(1).or("foo")

Right(1)

option Boolean GH

Boolean ⇒ A ⇒ Option[A]

Construct a Some if true, None if false

false.option(1)

None

true.option(1)

Some(1)

cond Boolean GH

Boolean ⇒ (⇒ A, ⇒ A) ⇒ A

Returns first value if true, second if false

false.cond(123, 456)

true.cond(123, 456)

implies Boolean GH

Boolean ⇒ Boolean ⇒ Boolean

Logical implication

false implies false

true

false implies true

true

true implies false

false

true implies true

true

nor Boolean GH

Boolean ⇒ Boolean ⇒ Boolean

Logical NOR

false nor false

true

false nor true

false

true nor false

false

true nor true

false

nand Boolean GH

Boolean ⇒ Boolean ⇒ Boolean

Logical NAND

false nand false

true

false nand true

true

true nand false

true

true nand true

false

calc A GH

A ⇒ (A ⇒ B) ⇒ B

Applies a function

12.calc(_ + 3)

 2.calc(_ * 3)

|> A GH

A ⇒ (A ⇒ B) ⇒ B

Applies a function

12 |> (_ + 3)

 2 |> (_ * 3)

calcIf A GH

A ⇒ Predicate[A] ⇒ (A ⇒ B) ⇒ Option[B]

Applies a function if a predicate holds

1.calcIf(_ > 1)(_ * 10)

None

2.calcIf(_ > 1)(_ * 10)

Some(20)

calcUnless A GH

A ⇒ Predicate[A] ⇒ (A ⇒ B) ⇒ Option[B]

Applies a function if a predicate does not hold

1.calcUnless(_ > 1)(_ * 10)

Some(10)

2.calcUnless(_ > 1)(_ * 10)

None

calcPF A GH

A ⇒ PartialFunction[A, B] ⇒ Option[B]

Applies a partial function

1 calcPF { case 2 ⇒ 20 }

None

2 calcPF { case 2 ⇒ 20 }

Some(20)

transform A GH

A ⇒ PartialFunction[A, A] ⇒ A

Applies a partial function

1 transform { case 2 ⇒ 20 }

2 transform { case 2 ⇒ 20 }

tapIf A GH

A ⇒ Predicate[A] ⇒ (A ⇒ Discarded)*) ⇒ A

Performs some actions if a predicate holds

1.tapIf(_ > 1)(print)

Does nothing

2.tapIf(_ > 1)(print)

prints "2"

tapUnless A GH

A ⇒ Predicate[A] ⇒ (A ⇒ Discarded)*) ⇒ A

Performs some actions if a predicate does not hold

1.tapUnless(_ > 1)(print)

prints "1"

2.tapUnless(_ > 1)(print)

Does nothing

tapPF A GH

A ⇒ PartialFunction[A, Discarded] ⇒ A

Performs an action

1 tapPF { case 2 ⇒ println("two !") }

Does nothing

2 tapPF { case 2 ⇒ println("two !") }

Prints "two !"

attempt A GH

A ⇒ (A ⇒ B) ⇒ Try[B]

Applies a function that can fail

1.attempt(_ ⇒ sys.error("boom !"))

Failure(Exception("boom !"))

1.attempt(_ * 2)

Success(2)

partialMatch A GH

A ⇒ PartialFunction[A, B] ⇒ Option[B]

Applies a partial function

1 partialMatch { case 2 ⇒ "two" }

None

2 partialMatch { case 2 ⇒ "two" }

Some("two")

lpair A GH

A ⇒ (A ⇒ B) ⇒ (B, A)

Applies a function & retain original value

1.lpair(_ * 2)

(2, 1)

rpair A GH

A ⇒ (A ⇒ B) ⇒ (A, B)

Retain original value & applies a function

1.rpair(_ * 2)

(1, 2)

filterSelf A GH

A ⇒ Predicate[A] ⇒ Option[A]

Retain original value if a predicate holds

1.filterSelf(_ > 1)

None

2.filterSelf(_ > 1)

Some(2)

ifSelf A GH

A ⇒ Predicate[A] ⇒ Option[A]

Retain original value if a predicate holds

1.ifSelf(_ > 1)

None

2.ifSelf(_ > 1)

Some(2)

filterNotSelf A GH

A ⇒ Predicate[A] ⇒ Option[A]

Retain original value if a predicate does not hold

1.filterNotSelf(_ > 1)

Some(1)

2.filterNotSelf(_ > 1)

None

unlessSelf A GH

A ⇒ Predicate[A] ⇒ Option[A]

Retain original value if a predicate does not hold

1.unlessSelf(_ > 1)

Some(1)

2.unlessSelf(_ > 1)

None

isOneOf A GH

A ⇒ A* ⇒ Boolean

Test if value is contained in a sequence

1.isOneOf(1, 2, 3)

true

4.isOneOf(1, 2, 3)

false

isNotOneOf A GH

A ⇒ A* ⇒ Boolean

Test if value is missing from a sequence

1.isNotOneOf(1, 2, 3)

false

4.isNotOneOf(1, 2, 3)

true

containedIn A GH

A ⇒ Set[A] ⇒ Boolean

Test if value is contained in a set

1.containedIn(Set(1, 2, 3()

true

4.containedIn(Set(1, 2, 3))

false

notContainedIn A GH

A ⇒ Set[A] ⇒ Boolean

Test if value is missing from a set

1.notContainedIn(Set(1, 2, 3))

false

4.notContainedIn(Set(1, 2, 3))

true

withFinally A GH

A ⇒ (A ⇒ Unit) ⇒ (A ⇒ B) ⇒ B

Applies a function and perform a cleanup action

1.withFinally(println)(_ * 2)

2 (and prints 1)

tryFinally A GH

A ⇒ (A ⇒ B) ⇒ (A ⇒ Unit) ⇒ B

Applies a function and perform a cleanup action

1.tryFinally(_ * 2)(println)

2 (and prints 1)

cond A GH

A ⇒ Predicate[A] ⇒ ((A ⇒ B), (A ⇒ B)) ⇒ B

Applies a choice of functions depending on whether a predicate holds

1.cond(_ > 1)("true: " + _)("false: " + _)

false: 1

2.cond(_ > 1)("true: " + _)("false: " + _)

true: 2

addTo A GH

A ⇒ Growable[A] ⇒ A

Adds value into a growable

1.addTo(ints)

ints += 1

removeFrom A GH

A ⇒ Shrinkable[A] ⇒ A

Removed value from a shrinkable

1.removeFrom(ints)

ints -= 1

unfold A GH

A ⇒ (A ⇒ Option[(B, A)]) ⇒ Stream[B]

Builds a stream by repeatedly applying a function

64.unfold(i ⇒ if (i > 1) Some((i, i/2)) else None)

Stream(64, 32, 16, 8, 4, 2)

update A GH

A ⇒ (A ⇒ Discarded)* ⇒ A

Performs some actions

1.tap(println)

Prints 1

withSideEffect A GH

A ⇒ (A ⇒ Discarded)* ⇒ A

Performs some actions

1.withSideEffect(println)

Prints 1

tap A GH

A ⇒ (A ⇒ Discarded)* ⇒ A

Performs some actions

1.update(println)

Prints 1

bounded A GH

A ⇒ (A, A) ⇒ (implicit Numeric[A]) ⇒ A

Constrain value to be between two others

0.bounded(1, 3)

2.bounded(1, 3)

5.bounded(1, 3)

ensure A GH

A ⇒ ( ⇒ E) ⇒ Predicate[A] ⇒ Validation[E, A]

Validates predicate

1.ensure("<= 1")(_ > 1)

Failure("<= 1")

2.ensure("<= 1")(_ > 1)

Success(2)

ensureNel A GH

A ⇒ ( ⇒ E) ⇒ Predicate[A] ⇒ ValidationNel[E, A]

1.ensureNel("<= 1")(_ > 1)

Failure(NonEmptyList("<= 1"))

2.ensureNel("<= 1")(_ > 1)

Success(2)

partitionEithers GTL[Either[L, R]] GH

GTL[Either[L, R]] ⇒ (GTL[L], GTL[R])

Partition eithers into lefts & rights

List(Right(3.0), Left(1), Right(4.0), Left(1)).partitionEithers

(List(1, 1), List(3.0, 4.0))

retainKeys mutable.Map[K, V] GH

mutable.Map[K, V] ⇒ Predicate[K] ⇒ mutable.Map[K, V]

Retain entries whose keys match the predicate

retainValues mutable.Map[K, V] GH

mutable.Map[K, V] ⇒ Predicate[V] ⇒ mutable.Map[K, V]

Retain entries whose values match the predicate

copyTo Array[A] GH

Array[A] ⇒ (Int, Array[A], Int, Int) ⇒ Array[A]

Copy subset of an array to another

Array(1, 2, 3, 4, 5).copyTo(2, Array(0, 0, 0, 0, 0), 1, 3)

Array(0, 3, 4, 5, 0)

naming ThreadFactory GH

ThreadFactory ⇒ (Int ⇒ String) ⇒ ThreadFactory

Adapt threads created by factory to be named

threadFactory.naming(i ⇒ s"Thread: $i").newThread(...).getName

Thread: 0

+++= mutable.Builder[A, B] GH

mutable.Builder[A, B] ⇒ TraversableOnce[TraversableOnce[A]] ⇒ mutable.Builder[A, B]

Adds the elements of several traversables

(new ListBuffer[Int] +++= List(List(1, 2), List(3), List(4))).result()

List(1, 2, 3, 4)

on mutable.Builder[A, B] GH

mutable.Builder[A, B] ⇒ (C ⇒ A) ⇒ mutable.Builder[C, B]

Change the type of element consumed by the builder

(new ListBuffer[Double].on[Int](_.toDouble)) += 3).result()

List(3.0)

reset mutable.Builder[A, B] GH

mutable.Builder[A, B] ⇒ B

Return result & clear

run mutable.Builder[A, B] GH

mutable.Builder[A, B] ⇒ (mutable.Builder[A, B] ⇒ Discarded)* ⇒ B

Update the builder & produce a result

new ListBufer[Int].run(_ += 1, _ ++= List(2, 3)

List(1, 2, 3)

collectHistogram GTL[A] GH

GTL[A] ⇒ PartialFunction[A, B] ⇒ Map[B, Int]

Calculate how many occurences of a property of each element

List("foo", "food", "bar", "oo").collectAttributeCounts {
  case word if word.size > 2 ⇒ word.size
}

// 2 words of length 3, 1 of length 4
Map(3 → 2, 4 → 1)

optHistogram GTL[A] GH

GTL[A] ⇒ (A ⇒ Option[B]) ⇒ Map[B, Int]

Calculate how many occurences of a property of each element

List("foo", "food", "bar", "oo").optAttributeCounts(
  word ⇒ if (word.size <= 2) None else Some(word.size)
)

// 2 words of length 3, 1 of length 4
Map(3 → 2, 4 → 1)

histogram GTL[A] GH

GTL[A] ⇒ (A ⇒ B) ⇒ Map[B, Int]

Calculate how many occurences of a property of each element

List("foo", "food", "bar", "oo").attributeCounts(
  word ⇒ word.size
)

// 1 word length 1, 2 of length 3, 1 of length 4
Map(2 → 1, 3 → 2, 4 → 1)

onlyOption GTL[A] GH

GTL[A] ⇒ Option[A]

Head if gtl has 1 element, None otherwise

Nil.onlyOption

None

Set(1).onlyOption

Some(1)

Vector(1, 2).onlyOption

None

onlyOrThrow GTL[A] GH

GTL[A] ⇒ (CC[A] ⇒ Exception) ⇒ A

Head if list gtl 1 element, throws otherwise

Nil.onlyOrThrow(l ⇒ new Throwable("Not singleton: "l.length)

throws "Not singleton: 0"

Set(1).onlyOrThrow(s ⇒ new Throwable("Not singleton: "s.length)

Vector(1, 2).onlyOrThrow(v ⇒ new Throwable("Not singleton: "v.length)

throws "Not singleton: 2"

onlyEither GTL[A] GH

GTL[A] ⇒ Either[CC[A], A]

Right if gtl has 1 element, Left otherwise

Nil.onlyEither

Left(Nil)

Set(1).onlyEither

Right(1)

Vector(1, 2).onlyEither

Left(Vector(1, 2))

asMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ (K, V)) ⇒ Map[K, V]

Build a map by specifying entries

List(2, 4).asMap.withEntries(i ⇒ (i/2, i*2))

Map(1 → 4, 2 → 8)

asMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ K, A ⇒ V) ⇒ Map[K, V]

Build a map by specifying keys & values

List(2, 4).asMap.withEntries(i ⇒ i/2, i ⇒ i*2)

Map(1 → 4, 2 → 8)

asMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ K1, A ⇒ K2, A ⇒ V) ⇒ Map[K1, Map[K2, V]]

Build a nested map by specifying keys & values

List(2, 4).asMap.withEntries(i ⇒ i/2, i ⇒ i, i ⇒ i*2)

Map(1 → Map(2 → 4), 2 → Map(4 → 8))

asMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ K1, A ⇒ K2, A ⇒ K3, A ⇒ V) ⇒ Map[K1, Map[K2, Map[K3, V]]]

Build a nested map by specifying keys & values

List(2, 4).asMap.withEntries(
  i ⇒ i/2, i ⇒ i, i ⇒ i*10, i ⇒ i*2
)

Map(
  1 → Map(2 → Map(20 → 4)),
  2 → Map(4 → Map(40 → 8))
)

asMap.withSomeEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ Option[(K, V)]) ⇒ Map[K, V]

Build a map by optionally specifying entries

List(2, 4).asMap.withSomeEntries(i ⇒ if (i == 2) Some((i/2, i*2)) else None)

Map(1, 4)

asMap.withSomeEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ Option[K], A ⇒ Option[V]) ⇒ Map[K, V]

Build a map by optionally specifying keys & values

List(3, 5, 15).asMap.withSomeEntries(
  i ⇒ if (i%3 == 0) Some(i/3) else None,
  i ⇒ if (i%5 == 0) Some(i/5) else None
)

Map(5 → 3)

asMap.withPFEntries GTL[A] GH

GTL[A] ⇒ PartialFunction[A, (K, V)] ⇒ Map[K, V]

Build a map by partially specifying entries

List(2, 4).asMap.withPFEntries { case 2 ⇒ (22, 222) }

Map(22 → 222)

asMap.withPFEntries GTL[A] GH

GTL[A] ⇒ (PartialFunction[A, K], PartialFunction[A, V]) ⇒ Map[K, V]

Build a map by partially specifying keys & values

List(1, 2, 3).asMap.withPFEntries({
  case 1 ⇒ 11
  case 3 ⇒ 33
}, {
  case 2 ⇒ 222
  case 3 ⇒ 333
})

Map(33 → 333)

asMultiMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ (K, V)) ⇒ MultiMap[GTL, [K, V]

Build a multi map by specifying entries

List(1, 2, 3).asMultiMap[List].withEntries(i ⇒ (i%2, i))

Map(0 → List(2), 1 → List(1, 3))

 List(1, 2, 3).asMultiMap[Set].withEntries(i ⇒ (i%2, i))

Map(0 → Set(2),  1 → Set(1, 3))

asMultiMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ K, A ⇒ V) ⇒ MultiMap[GTL, K, V]

Build a multi map by specifying keys & values

List(1, 2, 3).asMultiMap[List].withEntries(i ⇒ i%2, i ⇒ i))

Map(0 → List(2), 1 → List(1, 3))

 List(1, 2, 3).asMultiMap[Set].withEntries(i ⇒ i%2, i ⇒ i))

Map(0 → Set(2),  1 → Set(1, 3))

asMultiMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ K1, A ⇒ K2, A ⇒ V) ⇒ Map[K1, MultiMap[GTL, K2, V]]

Builds a nested multi map by specifying keys & values

List(1, 2, 3, 4).asMultiMap[List].withEntries(
  i ⇒ i%2, i ⇒ i/2, i ⇒ i
)

Map(
  0 -> Map(1 -> List(2), 2 -> List(4)),
  1 -> Map(0 -> List(1), 1 -> List(3))
)

asMultiMap.withEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ K1, A ⇒ K2, A ⇒ K3, A ⇒ V) ⇒ Map[K1, Map[K2, MultiMap[GTL, K3, V]]]

Builds a nested multi map by specifying keys & values...

List(1, 2, 3, 4).asMultiMap[List].withEntries(
  i ⇒ i%2, i ⇒ i/2, i ⇒ i*10, i ⇒ i
)

Map(
  0 -> Map(2 -> Map(40 -> List(4)), 1 -> Map(20 -> List(2))),
  1 -> Map(1 -> Map(30 -> List(3)), 0 -> Map(10 -> List(1)))
)

List(1, 2, 3, 4).asMultiMap[Set].withEntries(
  i ⇒ i%2, i ⇒ i/2, i ⇒ i*10, i ⇒ i
)

Map(
  0 -> Map(2 -> Map(40 -> Set(4)), 1 -> Map(20 -> Set(2))),
  1 -> Map(1 -> Map(30 -> Set(3)), 0 -> Map(10 -> Set(1)))
)

asMultiMap.withSomeEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ Option[(K, V)]) ⇒ MultiMap[GTL, K, V]

asMultiMap.withSomeEntries GTL[A] GH

GTL[A] ⇒ (A ⇒ Option[K], A ⇒ Option[V]) ⇒ MultiMap[GTL, K, V]

asMultiMap.withPFEntries GTL[A] GH

GTL[A] ⇒ PartialFunction[A, (K, V)] ⇒ MultiMap[GTL, K, V]

asMultiMap.withPFEntries GTL[A] GH

GTL[A] ⇒ (PartialFunction[A, K], PartialFunction[A, V]) ⇒ MultiMap[GTL, K, V]

ungroupBy GTL[A] GH

GTL[A] ⇒ (A ⇒ B) ⇒ GTL[GTL[A]]

partitionByPF GTL[A] GH

GTL[A] ⇒ PartialFunction[A, B] ⇒ (GTL[A], GTL[B])

all GTL[A] GH

GTL[A] ⇒ A ⇒ Boolean

none GTL[A] GH

GTL[A] ⇒ A ⇒ Boolean

seqFold GTL[A] GH

GTL[A] ⇒ B ⇒ ((B, A) ⇒ Option[B]) ⇒ Option[B]

seqMap GTL[A] GH

GTL[A] ⇒ (A ⇒ Option[B]) ⇒ (implicit CanBuildFrom[Nothing, B, To]) ⇒ Option[To]

apoFold GTL[A] GH

GTL[A] ⇒ B ⇒ ((B, A) ⇒ Either[C, B]) ⇒ Either[C, B]

ifSome Predicate[A] GH

Predicate[A] ⇒ Predicate[Option[A]]

Lift predicate to apply to Option

((i: Int) ⇒ i == 2).ifSome.apply(None)

false

((i: Int) ⇒ i == 2).ifSome.apply(Some(1))

false

((i: Int) ⇒ i == 2).ifSome.apply(Some(2))

true

and Predicate[A] GH

Predicate[A] ⇒ Predicate[A] ⇒ Predicate[A]

A predicate that's true only when both input predicates are true

((i: Int) ⇒ i % 3 == 0).and((i: Int) ⇒ i % 5 == 0).apply(1)

false

((i: Int) ⇒ i % 3 == 0).and((i: Int) ⇒ i % 5 == 0).apply(3)

false

((i: Int) ⇒ i % 3 == 0).and((i: Int) ⇒ i % 5 == 0).apply(5)

false

((i: Int) ⇒ i % 3 == 0).and((i: Int) ⇒ i % 5 == 0).apply(15)

true

or Predicate[A] GH

Predicate[A] ⇒ Predicate[A] ⇒ Predicate[A]

A predicate that's true when either input predicates are

((i: Int) ⇒ i % 3 == 0).or((i: Int) ⇒ i % 5 == 0).apply(1)

false

((i: Int) ⇒ i % 3 == 0).or((i: Int) ⇒ i % 5 == 0).apply(3)

true

((i: Int) ⇒ i % 3 == 0).or((i: Int) ⇒ i % 5 == 0).apply(5)

true

((i: Int) ⇒ i % 3 == 0).or((i: Int) ⇒ i % 5 == 0).apply(15)

true

exists Predicate[A] GH

Predicate[A] ⇒ Predicate[List[A]]

A predicate that's true when there exists an element that passes

((i: Int) ⇒ i == 2).exists.apply(Nil)

false

((i: Int) ⇒ i == 2).exists.apply(List(1))

false

((i: Int) ⇒ i == 2).exists.apply(List(2))

true

((i: Int) ⇒ i == 2).exists.apply(List(1, 2))

true

guard Predicate[A] GH

Predicate[A] ⇒ (A ⇒ B) ⇒ PartialFunction[A, B]

Limit a function by a predicate

((i: Int) ⇒ i == 2).guard(_ * 10).lift(1)

None

((i: Int) ⇒ i == 2).guard(_ * 10).lift(2)

Some(20)

cond Predicate[A] GH

Predicate[A] ⇒ (⇒ B, ⇒ B) ⇒ (A ⇒ B)

tailOption Stream[A] GH

Stream[A] ⇒ Option[Stream[A]]

The tail of the stream if it is not empty, None otherwise

Stream.empty[Int].tailOption

None

uncons Stream[A] GH

Stream[A] ⇒ (⇒ B, Stream[A] ⇒ B) ⇒ B

Convert to B depending on whether the stream is empty or not

   Stream.empty.uncons("[]", s ⇒ s"[${s.length} elements]"

"[]"

Stream(1, 2, 3).uncons("[]", s ⇒ s"[${s.length} elements]"

"[3 elements]"

unconsC Stream[A] GH

Stream[A] ⇒ (⇒ B, A ⇒ (⇒ Stream[A]) ⇒ B) ⇒ B

Convert to B with head & tail if non empty, default otherwise

   Stream.empty.unconsC("[]", h ⇒ t ⇒ s"[$h .. ${t.length} more]"

"[]"

Stream(1, 2, 3).unconsC("[]", h ⇒ t ⇒ s"[$h .. ${t.length} more]"

"[1, 2 more]"

lazyScanLeft Stream[A] GH

Stream[A] ⇒ B ⇒ ((B, A) ⇒ B) ⇒ Stream[B]

scanLeft that works on infinite or blocking streams

(1 #:: {synchronized(wait(0)); Stream(2)}).lazyScanLeft(0)(_ + _).take(1).toList

List(1)

reverseInits Stream[A] GH

Stream[A] ⇒ Stream[Stream[A]]

inits that works on infinite or blocking streams

Stream.iterate(0)(_ + 1).reverseInits.take(3)

Stream(Stream.empty, Stream(0), Stream(0, 1))

toMultiMap FilterMonadic[(K, V)] GH

FilterMonadic[(K, V)] ⇒ MultiMap[List, K, V]

Convert to MultiMap

List((1, 11), (2, 22), (1, 111)).toMultiMap[Set]

Map(1 → Set(11, 111), 2 → Set(22))

closeAfter InputStream GH

InputStream ⇒ (InputStream ⇒ A) ⇒ A

Close after applying function

new ByteArrayInputStream(Array(123)).closeAfter(_.read())

isChildOf File GH

File ⇒ File ⇒ Boolean

Check if file is a child of another

new File("/etc/password").isChildOf("/etc")

true

new File("/etc/password").isChildOf("/")

false

isParentOf File GH

File ⇒ File ⇒ Boolean

Check if file is parent of another

new File("/etc").isParentOf("/etc/password")

true

   new File("/").isParentOf("/etc/password")

false

readLines File GH

File ⇒ implicit Codec ⇒ List[String]

className File GH

File ⇒ File ⇒ String

md5 File GH

File ⇒ String

batchBy List[A] GH

List[A] ⇒ (A ⇒ B) → List[List[A]]

Split into batches whenever result of function changes

List(1, 2, -1, -2, 3, -3, -4).batchBy(_ >= 0)

List(List(1, 2), List(-1, -2), List(3), List(-3, -4))

countBy List[A] GH

List[A] ⇒ MultiMap[List, Int, A]

Group by number of occurrences of function result

List(1, 2, -1, -2, 3, -3, -4).countBy(_ >= 0)

Map(3 → List(1, 2, 3), 4 → List(-1, -2, -3, -4))

distinctBy List[A] GH

List[A] ⇒ (A ⇒ B) ⇒ List[A]

Retain only the first occurrence of an element whose function result is repeated

List("foo", "food", "oof", "foods").distinctBy(_.length))

List("food", "foods")

duplicatesBy List[A] GH

List[A] ⇒ (A ⇒ B) ⇒ List[A]

Retain only those elements whose function result is repeated

List("foo", "food", "oof", "foods", "doof").duplicatesBy(_.length))

List("foo", "food", "oof", "doof")

duplicates List[A] GH

List[A] ⇒ List[A]

Retain only those elements which are repeated

List(1, 2, 3, 1, 4, 3).duplicates

LIst(1, 3)

const List[A] GH

List[A] ⇒ B ⇒ List[A]

Replace all elements with a constant value

List(1, 2, 3).const("foo")

List("foo", "foo", "foo")

lpair List[A] GH

List[A] ⇒ A => B => List[(B, A)]

Pair up each element with the result of f

List(1, 2, 3).lpair(_ * 2)

List((2,1), (4,2), (6,3)))

rpair List[A] GH

List[A] ⇒ A => B => List[(A, B)]

Pair up each element with the result of f

List(1, 2, 3).lpair(_ * 2)

List((1,2), (2,4), (3,6)))

countWithSize List[A] GH

List[A] ⇒ Predicate[A] ⇒ Option[(Int, Int)]

Count number of times a predicate passes, along with the list size

Nil.countWithSize(_ >= 0)

None

List(1, 2, -2, 3, -4, 5).countWithSize(_ >= 0)

Some((4, 6))

sizeGT List[A] GH

List[A] ⇒ Int ⇒ Boolean

Determine if the list size exceeds some value

List(1, 2, 3).sizeGT(2)

true

List(1, 2, 3).sizeGT(3)

false

fraction List[A] GH

List[A] ⇒ Predicate[A] ⇒ Double

Determine what fraction of the list passes some predicate

Nil.fraction(_ >= 0)

Double.NaN

List(1, 2, -2, 3, -4, 5).fracton(_ >= 0)

Some(0.667)

emptyTo List[A] GH

List[A] ⇒ List[A] ⇒ List[A]

Replace empty list with supplied value

List(1, 2).emptyTo(List(3, 4))

List(1, 2)

Nil.emptyTo(List(3, 4))

List(3, 4)

headTail List[A] GH

List[A] ⇒ (A, List[A])

The head & tail if the list is non empty, throws otherwise

List(1, 2, 3).headTail

(1, List(2, 3))

Nil.headTail

throws "headTail of empty list"

headTailOption List[A] GH

List[A] ⇒ Option[(A, List[A])]

The head & tail if the list is non empty, None otherwise

List(1, 2, 3).headTailOPtion

Some((1, List(2, 3)))

Nil.headTailOption

None

initOption List[A] GH

List[A] ⇒ Option[List[A]]

The init if the list is non empty, None otherwise

List(1, 2, 3).initOption

Some(List(1, 2))

Nil.initOption

None

tailOption List[A] GH

List[A] ⇒ Option[List[A]]

The tail if the list is non empty, None otherwise

List(1, 2, 3).tailOption

Some(List(2, 3))

Nil.tailOption

None

initLast List[A] GH

List[A] ⇒ (List[A], A)

The init & last if the list is non empty, throws otherwise

List(1, 2, 3).initLast

(List(1, 2), 3)

Nil.initLast

throws "initLast of empty list"

initLastOption List[A] GH

List[A] ⇒ Option[(List[A], A)]

The init & last if the list is non empty, None otherwise

List(1, 2, 3).initLastOption

Some((List(1, 2), 3))

Nil.initLastOption

None

prefixPadTo List[A] GH

List[A] ⇒ (Int, A) ⇒ List[A]

Prefix lists smaller than provide size with repetitions of the provided element

List(1, 2).prefixPadTo(1, 99)

List(1, 2)

List(1, 2).prefixPadTo(4, 99)

List(99, 99, 1, 2)

sharedPrefix List[A] GH

List[A] ⇒ List[A] ⇒ (implicit A ⇒ A ⇒ Boolean) ⇒ (List[A], List[A], List[A])

Split list into parts shared with the beginning of another, along with the remainder of each

List(1, 2, 3, 4).sharedPrefix(List(1, 2, 4, 3))

(List(1, 2), List(3, 4), List(4, 3))

amass List[A] GH

List[A] ⇒ PartialFunction[A, List[B]] ⇒ List[B]

filter andThen flatMap

List(1, 2, 3, 4).amass { case i if i % 2 == 0 ⇒ List(i, -i) }

List(2, -2, 4, -4)

calcIfNonEmpty List[A] GH

List[A] ⇒ (List[A] ⇒ B) ⇒ Option[B]

Calculate result if non empty, None otherwise

Nil.calcIfNonEmpty(_.length)

None

List(1, 2, 3).calcifNonEmpty(_.length)

Some(3)

mapIfNonEmpty List[A] GH

List[A] ⇒ (A ⇒ B) ⇒ Option[List[B]]

Map if non empty, None otherwise

Nil.mapIfNonEmpty(_ * 10)

None

List(1, 2, 3).mapIfNonEmpty(_ * 10)

Some(List(10, 20, 30))

onlyDisjunction List[A] GH

List[A] ⇒ List[A] \/ A

\/- if list has 1 element, -\/ otherwise

Nil.onlyDisjunction

-\/(Nil)

List(1).onlyDisjunction

\/-(1)

List(1, 2).onlyDisjunction

-\/(List(1, 2))

uncons List[A] GH

List[A] ⇒ (⇒ B, List[A] ⇒ B) ⇒ B

Convert to B depending on whether the list is empty or not

          Nil.uncons("[]", l ⇒ s"[${l.length} elements]"

"[]"

List(1, 2, 3).uncons("[]", l ⇒ s"[${l.length} elements]"

"[3 elements]"

unconsC List[A] GH

List[A] ⇒ (⇒ B, A ⇒ List[A] ⇒ B) ⇒ B

Convert to B with head & tail if non empty, default otherwise

          Nil.unconsC("[]", h ⇒ t ⇒ s"[$h .. ${t.length} more]"

"[]"

List(1, 2, 3).unconsC("[]", h ⇒ t ⇒ s"[$h .. ${t.length} more]"

"[1, 2 more]"

unsnocC List[A] GH

List[A] ⇒ (⇒ B, List[A] ⇒ A ⇒ B) ⇒ B

Convert to B with init & last if non empty, default otherwise

          Nil.unsnocC("[]", i ⇒ l ⇒ s"[${i.length} previous, $l]"

"[]"

List(1, 2, 3).unsnocC("[]", i ⇒ l ⇒ s"[${i.length} previous, $l]"

"[2 previous, 3]"

tapNonEmpty List[A] GH

List[A] ⇒ List[A] ⇒ Discarded

Perform an action if the list is non empty

    Nil.tapNonEmpty(l ⇒ print("non-empty: " + l))

Does nothing

List(1).tapNonEmpty(l ⇒ print("non-empty: " + l))

Prints "non-empty: List(1)"

tapEmpty List[A] GH

List[A] ⇒ (⇒ Discarded) ⇒ List[A]

Perform an action if the list is empty

    Nil.tapEmpty(print("empty"))

Prints "empty"

List(1).tapEmpty(print("empty"))

Does nothing

tap List[A] GH

List[A] ⇒ (⇒ Discarded, List[A] ⇒ Discarded) ⇒ List[A]

Perform an action depending on whether the list is empty or not

    Nil.tap(print("empty"), l ⇒ print("non-empty: " + l))

Prints "empty"

List(1).tap(print("empty"), l ⇒ print("non-empty: " + l))

Prints "non-empty: List(1)"

zipWith List[A] GH

List[A] ⇒ List[B] ⇒ ((A, B) ⇒ C) ⇒ List[C]

Combine with another list element-wise

List(1, 2).zipWith(List('z', 'x')) { case (i, c) ⇒ s"i: $i, c: $c"}

List("i: 1, c: z", "i: 2, c: x")

   List(1).zipWith(List('z', 'x')) { case (i, c) ⇒ s"i: $i, c: $c"}

List("i: 1, c: z")

List(1, 2).zipWith(List('z'))      { case (i, c) ⇒ s"i: $i, c: $c"}

List("i: 1, c: z")

zipToMap List[A] GH

List[A] ⇒ List[V] ⇒ Map[A, V]

Combine with another list element-wise to form a Map

List(1, 2).zipToMap(List('z', 'x'))

Map(1 → 'z', 2 → 'x')

   List(1).zipToMap(List('z', 'x'))

Map(1 → 'z')

List(1, 2).zipToMap(List('z'))

Map(1 → 'z')

zipExact List[A] GH

List[A] ⇒ List[B] ⇒ (List[(A, B)], Option[Either[List[A], List[B]]])

Losslessly combine with another list element-wise

List(1, 2).zipExact(List('z', 'x'))

(List((1, 'z'), (2, 'x')), None)

   List(1).zipExact(List('z', 'x'))

(List((1, 'z')), Some(Right('x')))

List(1, 2).zipExact(List('z'))

(List((1, 'z')), Some(Left(1)))

zipExactWith List[A] GH

List[A] ⇒ List[B] ⇒ ((A, B) ⇒ C) ⇒ (List[C], Option[Either[List[A], List[B]]])

Losslessly combine with another list element-wise

List(1, 2).zipExactWith(List(10.0, 20.0))(_ + _)

(List(11.0, 22.0), None)

   List(1).zipExactWith(List(10.0, 20.0))(_ + _)

(List(11.0), Some(Right(20.0))

List(1, 2).zipExactWith(List(10.0      ))(_ + _)

(List(11.0), Some(Left(2)))

sortPromoting List[A] GH

List[A] ⇒ A* ⇒ (implicit Ordering[A]) ⇒ List[A]

When sorting promote specified elements, otherwise use existing ordering

List("red", "green", "blue", "cyan").sortPromoting("cyan", "green")

List("cyan", "green", "blue", "red")

sortDemoting List[A] GH

List[A] ⇒ A* ⇒ (implicit Ordering[A]) ⇒ List[A]

When sorting demote specified elements, otherwise use existing ordering

List("blue", "red", "cyan", "green").sortDemoting("green", "blue")

List("cyan", "red", "green", "blue")

toNel List[A] GH

List[A] ⇒ Option[NonEmptyList[A]]

Convert to non-empty list, if possible

Nil.toNel

None

List(1, 2).toNel

Some(NonEmptyList(1, 2))

max NonEmptyList[A: Order] GH

NonEmptyList[A: Order] ⇒ A

Maximum value

NonEmptyList(3, 1, 4).max

min NonEmptyList[A: Order] GH

NonEmptyList[A: Order] ⇒ A

Minimum value

NonEmptyList(3, 1, 4).min

toLeft PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ A ⇒ Either[B, A]

toRight PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ A ⇒ Either[A, B]

either PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ A ⇒ Either[A, B]

partition PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ CC[A] ⇒ (CC[A], CC[B])

isUndefinedAt PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ A ⇒ Boolean

first PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ PartialFunction[(A, C), (B, C)]

second PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ PartialFunction[(C, A), (C, B)]

unify PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ A ⇒ A

map PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ (B ⇒ C): PartialFunction[A, C]

contramap PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ (C ⇒ A)

PartialFunction[C, B]

*** PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ PartialFunction[C, D] ⇒ PartialFunction[(A, C), (B, D)]

&&& PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ PartialFunction[A, C] ⇒ PartialFunction[A, (B, C)]

||| PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ PartialFunction[C, B] ⇒ PartialFunction[Either[A, C], B]

\/ PartialFunction[A, B] GH

PartialFunction[A, B] ⇒ PartialFunction[C, B] ⇒ PartialFunction[A \/ C, B]

toMultiMap GTL[(K, V)] GH

GTL[(K, V)] ⇒ MultiMap[F, K, V]

beforeDecode DecodeJson[A] GH

DecodeJson[A] ⇒ (Json ⇒ Json) ⇒ DecodeJson[A]

Pre-processes json before decoding

compose DecodeJson[A] GH

DecodeJson[A] ⇒ (Json ⇒ Json) ⇒ DecodeJson[A]

Pre-processes json before decoding

upcast DecodeJson[A] GH

DecodeJson[A] ⇒ DecodeJson[B]

Upcasts results after decoding

asMap.withValues GTL[K] GH

GTL[K] ⇒ (K ⇒ V) ⇒ Map[K, V]

asMap.withSomeValues GTL[K] GH

GTL[K] ⇒ (K ⇒ Option[V]) ⇒ Map[K, V]

asMap.withPFValues GTL[K] GH

GTL[K] ⇒ PartialFunction[K, V] ⇒ Map[K, V]

asMap.withConstValue GTL[K] GH

GTL[K] ⇒ V ⇒ Map[K, V]

asMultiMap.withValues GTL[K] GH

GTL[K] ⇒ (K ⇒ V) ⇒ MultiMap[GTL, K, V]

asMultiMap.withSomeValues GTL[K] GH

GTL[K] ⇒ (K ⇒ Option[V]) ⇒ MultiMap[GTL, K, V]

asMultiMap.withPFValues GTL[K] GH

GTL[K] ⇒ PartialFunction[K, V] ⇒ MultiMap[GTL, K, V]

asMultiMap.withConstValue GTL[K] GH

GTL[K] ⇒ V ⇒ MultiMap[GTL, K, V]

afterEncode EncodeJson[A] GH

EncodeJson[A] ⇒ (Json ⇒ Json) ⇒ EncodeJson[A]

Post-processes json after encoding

andThen EncodeJson[A] GH

EncodeJson[A] ⇒ (Json ⇒ Json) ⇒ EncodeJson[A]

Post-processes json after encoding

downcast EncodeJson[A] GH

EncodeJson[A] ⇒ EncodeJson[B]

Downcasts values before encoding

toHex Array[Byte] GH

Array[Byte] ⇒ String

Convert to hex string

Array[Byte](126, 87, -85, 30).toHex

7e57ab1e

toHex Array[Byte] GH

Array[Byte] ⇒ Int ⇒ String

Convert to hex & prefix up to a certain length

Array[Byte](126, 87, -85, 30).toHex(10)

007e57ab1e

copyUpToN Array[Byte] GH

Array[Byte] ⇒ (Long, InputStream, OutputStream) ⇒ Int

Use array as buffer to copy up to n bytes from an InputStream to an OutputStream

readUpToN Array[Byte] GH

Array[Byte] ⇒ (Long, InputStream) ⇒ Int

Read up to n bytes from an InputStream

unlift (A ⇒ Option[B]) GH

(A ⇒ Option[B]) ⇒ PartialFunction[A, B]

Create partial function

addTo (A, B) GH

(A, B) ⇒ (Growable[A], Growable[B]) ⇒ (A, B)

Adds values into growables

(1, "foo").addTo(ints, strings)

ints += 1; strings += "foo"

removeFrom (A, B) GH

(A, B) ⇒ (Shrinkable[A], Shrinkable[B]) ⇒ (A, B)

Removes values from a shrinkables

(1, "foo").removeFrom(ints, strings)

ints -= 1; strings -= "foo"

tap (A, B) GH

(A, B) ⇒ (A ⇒ B ⇒ Discarded) ⇒ (A, B)

Performs an action

(1, "foo").tap(i ⇒ s ⇒ println(s"int: $i, string: $s")

Prints "int: 1, string: foo"

calc (A, B) GH

(A, B) ⇒ ((A, B) ⇒ C) ⇒ C

Applies a function

(1, "foo").calc { case (i, s) ⇒ s"int: $i, string: $s" }

"int: 1, string: foo"

calcC (A, B) GH

(A, B) ⇒ (A ⇒ B ⇒ C) ⇒ C

Applies a curried function

(1, "foo").calc(i ⇒ s ⇒ s"int: $i, string: $s")

"int: 1, string: foo"

to (A, B) GH

(A, B) ⇒ (implicit A ⇒ C, B ⇒ C) ⇒ (C, C)

Converts all elements to a common type

(123, 456.0).to[String]

("123", "456.0")

tmap (A, B) GH

(A, B) ⇒ (A ⇒ C, B ⇒ D) ⇒ (C, D)

Applies functions to each element

(1, "foo").tmap(_ * 2, _.reverse)

(2, "oof")

notContains Set[A] GH

Set[A] ⇒ A ⇒ Boolean

Tests if some element is absent in this set

Set(1, 2).notContains(1)

false

Set(1, 2).notContains(3)

true

mutable Set[A] GH

Set[A] ⇒ mutable.Set[A]

Convert to mutable set

toMutable Set[A] GH

Set[A] ⇒ mutable.Set[A]

Convert to mutable set

powerSet Set[A] GH

Set[A] ⇒ Set[Set[A]]

All possble subsets of the set

Set(1, 2, 3).powerSet

Set(1, 2, 3), Set(1, 2), Set(1, 3), Set(2, 3), Set(1), Set(2), Set(3), Set())

partitionDisjunctions GTL[L \/ R] GH

GTL[L \/ R] ⇒ (GTL[L], GTL[R])

Partition disjunctions into lefts & rights

List(\/-(3.0), -\/(1), \/-(4.0), -\/(1)).partitionDisjunctions

(List(1, 1), List(3.0, 4.0))

flatten (L \/ (L \/ R)) GH

(L \/ (L \/ R)) ⇒ L \/ R

Flattens two level disjunction into one

-\/(1).flatten

-\/(1)

\/-(-\/(2)).flatten

-\/(2)

\/-(\/-("s"))).flatten

\/-("s")

addDay Date GH

Date ⇒ Int ⇒ Date

Adds n days to date

Date().addDay(2)

mapC List[(A, B) GH

List[(A, B) ⇒ A => B => C => List[C]

Curried map method

List((1, 2), (2, 3)).mapC(a ⇒ b ⇒ a * b)

List(2, 6)

mapKeys DecodeJson[Map[K, V]] GH

DecodeJson[Map[K, V]] ⇒ (K ⇒ C) ⇒ DecodeJson[Map[C, V]]

Converts map keys after decoding

mapDecoder.mapKeys(_.reverse).decodeJson({ "foo" → "bar" })

Map("oof" → "bar")

mapValues DecodeJson[Map[K, V]] GH

DecodeJson[Map[K, V]] ⇒ (V ⇒ W) ⇒ DecodeJson[Map[K, W]]

Converts map values after decoding

mapDecoder.mapValues(_.reverse).decodeJson({ "foo" → "bar" })

Map("foo" → "rab")

attempt Callable[A] GH

Callable[A] ⇒ Callable[Try[A]]

Wrap result in Try

cartesianProduct List[List[A]] GH

List[List[A]] ⇒ List[List[A]]

Every permutation of elements choosen from each list

List(List(1,2,3), List(8,9)).cartesianProduct

List(List(1,8), List(1,9), List(2,8), List(2,9), List(3,8), List(3,9))

flatten ((L \/ R) \/ R) GH

((L \/ R) \/ R) ⇒ L \/ R

Flattens two level disjunction into one

-\/(-\/(1)).flatten

-\/(1)

-\/(\/-("s")).flatten

\/-("s")

\/-("s").flatten

\/-("s")

asMap.withKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ K) ⇒ Map[K, V]

asMap.withSomeKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ Option[K]) ⇒ Map[K, V]

asMap.withManyKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ List[K]) ⇒ Map[K, V]

asMap.withUniqueKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ K) ⇒ Option[Map[K, V]]

asMap.withPFKeys GTL[V] GH

GTL[V] ⇒ PartialFunction[V, K] ⇒ Map[K, V]

asMultiMap.withKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ K) ⇒ MultiMap[GTL, K, V]

asMultiMap.withSomeKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ Option[K]) ⇒ MultiMap[GTL, K, V]

asMultiMap.withManyKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ List[K]) ⇒ MultiMap[GTL, K, V]

asMultiMap.withUniqueKeys GTL[V] GH

GTL[V] ⇒ (V ⇒ K) ⇒ Option[MultiMap[GTL, K, V]]

asMultiMap.withPFKeys GTL[V] GH

GTL[V] ⇒ PartialFunction[V, K] ⇒ MultiMap[GTL, K, V]

select MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ F[V] ⇒ W ⇒ Map[K, W]

Choose a slice of the multimap, equivalent to Map[K, F[V]].mapValuesEagerly

Map(1 → List(1, 11), 2 → List(2, 22)).select(_.last)

Map(1 → 11, 2 → 22)

merge MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ MultiMap[F, K, V] ⇒ MultiMap[F, K, V]

Combines two multimaps by concatenating their values

Map(1 → List(1), 3 → List(3)).merge(Map(2 → List(2), 3 → List(33))

Map(1 → List(1), 2 → List(2), 3 → List(3, 33))

append MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ (K, F[V]) ⇒ MultiMap[F, K, V]

Appends a single entry, concatenating if already present

Map(1 → List(11)).append(2, List(22))

Map(1 → List(11), 2 → List(22))

Map(1 → List(11)).append(1, List(111))

Map(1 → List(11, 111))

multiMap.head MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ Map[K, V]

Selects the head element of each value

Map(1 → List(11), 2 → List(22, 222)).multiMap.head

Map(1 → 11, 2 → 22)

multiMap.tail MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ MultiMap[F, K, V]

Selects the tail of each value, only retains non-empty values

Map(1 → List(1, 11), 2 → List(22), 3 → Nil).multiMap.tail

Map(1 → List(11))

multiMap.reverse MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ MultiMap[F, V, K]

Reverses the multimap

Map('a' → List(1, 2), 'b' → List(2, 3)).reverse

Map(1 → List('a'), 2 → List('a', 'b'), 3 → List('b'))

multiMap.mapEntries MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ (K ⇒ F[V] ⇒ (C, F[W])) ⇒ MultiMap[F, C, W]

Map over each entry to produce another multimap

Map(2 → List(2, 22)).mapEntries(key ⇒ values ⇒ (key * 10, List(values.sum)))

Map(20 → List(24))

multiMap.mapEntriesU MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ (K ⇒ F[V] ⇒ (C, G[W])) ⇒ MultiMap[G, C, W]

Map over each entry to produce another type of multimap

Map(2 → List(2, 22)).mapEntriesU(key ⇒ values ⇒ (key * 10, Set(values.sum)))

Map(20 → Set(24))

multiMap.values MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ F[V]

Concatenate values

Map(1 → List(1), 2 → List(2, 22)).multiMap.values

List(1, 2, 22)

multiMap.sliding MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ Int ⇒ F[MultiMap[F, K, V]]

Produce a sequence of multimaps that slide across the original

Map(1 → List(11, 12, 13), 2 → List(21, 22, 23)).multiMap.sliding(2)

List(Map(1 → List(11, 12), 2 → List(21, 22)), Map(1 → List(12, 13), 2 → List(22, 23)))

pop MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ K ⇒ MultiMap[F, K, V]

Removes head value associated with key, discarding empty values entirely

Map(1 → List(2, 3), 2 → List(3)).pop(1)

Map(1 → List(3), 2 → List(3))

Map(1 → List(2, 3), 2 → List(3)).pop(2)

Map(1 → List(2, 3))

Map(1 → List(2, 3), 2 → List(3)).pop(3)

Map(1 → List(2, 3), 2 → List(3)))

sequence MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ F[Map[K, V]]

Convert a multimap to a sequence of maps

Map(1 → List(10, 11), 2 → List(20, 21)).sequence

List(Map(1 → 10, 2 → 20), Map(1 → 11, 2 → 21))

headTailOption MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ Option[(Map[K, V], MultiMap[F, K, V])]

The head & tail if the multimap is non empty, None otherwise

Map(1 → List(10, 11), 2 → List(20)).headTailOption

Some(Map(1 → 10, 2 → 20), Map(1 → List(11)))

Map(1 → Nil, 2 → List(20)).headTailOption

Some(Map(2 → 20), Map())

Map(1 → (Nil: List[Int])).headTailOption

None

MultiMap.empty[List, Int, Int]

None

flatMapValues MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ (V ⇒ F[W]) ⇒ MultiMap[F, K, W]

Expand each value to a collection of values

Map(0 → List(1, 2)).flatMapValues(v ⇒ List(v, -v))

Map(0 → List(1, -1, 2, -2))

flatMapValuesU MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ (V ⇒ G[W]) ⇒ MultiMap[G, K, W]

Expand each value to a different type of collection of values

Map(0 → List(1, 2)).flatMapValuesU(v ⇒ Set(v, -v))

Map(0 → Set(1, -1, 2, -2))

getOrEmpty MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ K ⇒ F[V]

Retrive the values associated with a key or an empty collection

Map(1 → List(2)).getOrEmpty(1)

List(2)

Map(1 → List(2)).getOrEmpty(2)

Nil

onlyOption MultiMap[F, K, V] GH

MultiMap[F, K, V] ⇒ Option[Map[K, V]]

Returns Some map if the multimap only contains empty or singleton containers, None otherwise

Map(1 → Nil, 2 → List(22)).onlyOption

Some(Map(2 → 22))

Map(1 → List(1, 11)).onlyOption

None

string Traversal[Json, Json] GH

Traversal[Json, Json] ⇒ Traversal[Json, String]

compose with string prism

Traversal.id[Json].string.getAll(Json.jString("foo"))

List("foo")

Traversal.id[Json].string.getAll(Json.jNumber(3))

Nil

int Traversal[Json, Json] GH

Traversal[Json, Json] ⇒ Traversal[Json, String]

compose with int prism

Traversal.id[Json].int.getAll(Json.jString("foo"))

Nil

Traversal.id[Json].int.getAll(Json.jNumber(3))

List(3)

filterNulls Json GH

Json ⇒ Json

Recursively removes null values

null

null

{ "a": null, "b": 3 }

{ "b": 3 }

[ "a", null, "b" ]

[ "a", "b" ]

{ "o": [ "a", null, "b" ] }

{ "o": [ "a", "b" ] }

[ { "a": null, "b": 3 } ]

[ { "b": 3 } ]

as[F] NonEmptyList[K] GH

NonEmptyList[K] ⇒

unique NonEmptyList[A] GH

NonEmptyList[A] ⇒ NonEmptyList[A]

Remove duplicates

NonEmptyList(3, 1, 4, 3, 4).unique

NonEmptyList(3, 1, 4)

uniqueBy NonEmptyList[A] GH

NonEmptyList[A] ⇒ (A ⇒ B) ⇒ NonEmptyList[A]

Remove items with duplicate properties

NonEmptyList("foo", "bar", "bare", "food").uniqueBy(_.length)

NonEmptyList("foo", "bare")

filter NonEmptyList[A] GH

NonEmptyList[A] ⇒ Predicate[A]

filters the NonEmptyList

   NonEmptyList(1).filter(_ % 2 == 0)

None

NonEmptyList(1, 2).filter(_ % 2 == 0)

Some(NonEmptyList(2))

filterNot NonEmptyList[A] GH

NonEmptyList[A] ⇒ Predicate[A]

filters the NonEmptyList

   NonEmptyList(2).filterNot(_ % 2 == 0)

None

NonEmptyList(1, 2).filterNot(_ % 2 == 0)

Some(NonEmptyList(1))

onlyOption NonEmptyList[A] GH

NonEmptyList[A] ⇒ Option[A]

Head if non-empty list has 1 element, None otherwise

NonEmptyList(1).onlyOption

Some(1)

NonEmptyList(1, 2).onlyOption

None

onlyEither NonEmptyList[A] GH

NonEmptyList[A] ⇒ Either[NonEmptyList[A], A]

Right if non-empty list has 1 element, Left otherwise

NonEmptyList(1).onlyEither

Right(1)

NonEmptyList(1, 2).onlyEither

Left(NonEmptyList(1, 2))

onlyDisjunction NonEmptyList[A] GH

NonEmptyList[A] ⇒ NonEmptyList[A] \/ A

\/- if list has 1 element, -\/ otherwise

NonEmptyList(1).onlyDisjunction

\/-(1)

NonEmptyList(1, 2).onlyDisjunction

-\/(NonEmptyList(1, 2))

attempt (A ⇒ B) GH

(A ⇒ B) ⇒ (A ⇒ Try[B])

guardWith (A ⇒ B) GH

(A ⇒ B) ⇒ Predicate[A] ⇒ PartialFunction[A, B]

beforeDecode CodecJson[A] GH

CodecJson[A] ⇒ (Json ⇒ Json) ⇒ CodecJson[A]

Pre-processes json before decoding

afterDecode CodecJson[A] GH

CodecJson[A] ⇒ (A ⇒ A) ⇒ CodecJson[A]

Converts after decoding

beforeEncode CodecJson[A] GH

CodecJson[A] ⇒ (A ⇒ A) ⇒ CodecJson[A]

Converts before encoding

afterEncode CodecJson[A] GH

CodecJson[A] ⇒ (Json ⇒ Json) ⇒ CodecJson[A]

Post-processes json after encoding

andThen CodecJson[A] GH

CodecJson[A] ⇒ (Json ⇒ Json) ⇒ CodecJson[A]

Post-processes json after encoding

compose CodecJson[A] GH

CodecJson[A] ⇒ (Json ⇒ Json) ⇒ CodecJson[A]

Pre-processes json before decoding

emptyTo String GH

String ⇒ String ⇒ String

Convert empty strings to another

"".emptyTo("replacement")

"replacement"

"non-empty".emptyTo("replacement")

"non-empty"

prefixPadTo String GH

String ⇒ (Int, Char) ⇒ String

suffixWith String GH

String ⇒ String ⇒ String

Add suffix to string if absent

"file".suffixWith(".txt")

"file.txt"

"file.txt".suffixWith(".txt")

"file.txt"

prefixWith String GH

String ⇒ String ⇒ String

Add prefix to string if absent

"file".prefixWith("dir/")

"dir/file"

"dir/file".prefixWith("dir/")

"dir/file"

affixWith String GH

String ⇒ String => String ⇒ String

Add prefix & suffix to string if absent

"file".affixWith("dir/", ".txt")

"dir/file.txt"

"file.txt".affixWith("dir/", ".txt")

"dir/file.txt"

"dir/file".affixWith("dir/", ".txt")

"dir/file.txt"

"dir/file.txt".affixWith("dir/", ".txt")

"dir/file.txt"

stripAffixes String GH

String ⇒ String => String ⇒ String

Remove prefix & suffix from string

"file".stripAffixes("dir/", ".txt")

"file"

"file.txt".stripAffixes("dir/", ".txt")

"file"

"dir/file".stripAffixes("dir/", ".txt")

"file"

"dir/file.txt".stripAffixes("dir/", ".txt")

"file"

sharedPrefix String GH

String ⇒ String ⇒ (String, String, String)

Split string into parts shared with the beginning of another, along with the remainder of each

"1234".sharedPrefix("1243")

("12", "34", "43")

md5 String GH

String ⇒ String

toByteArray String GH

String ⇒ Array[Byte]

toByteArray String GH

String ⇒ CharSet ⇒ Array[Byte]

tap (L \/ R) GH

(L \/ R) ⇒ (L ⇒ Discarded, R ⇒ Discarded) ⇒ L \/ R

Perform one action or another

   -\/(1).tap(l ⇒ print("left: " + l), r ⇒ print("right: " + r))

Prints "left: 1"

\/-(true).tap(l ⇒ print("left: " + l), r ⇒ print("right: " + r))

Prints "right: true"

tapLeft (L \/ R) GH

(L \/ R) ⇒ (L ⇒ Discarded) ⇒ L \/ R

Perform action if Left

   -\/(1).tapLeft(l ⇒ print("left: " + l))

Prints "left: 1"

\/-(true).tapLeft(l ⇒ print("left: " + l))

Does nothing

tapRight (L \/ R) GH

(L \/ R) ⇒ (R ⇒ Discarded) ⇒ L \/ R

Perform action if Right

   -\/(1).tap(r ⇒ print("right: " + r))

Does nothing

\/-(true).tap(r ⇒ print("right: " + r))

Prints "right: true"

addTo (L \/ R) GH

(L \/ R) ⇒ (Growable[L], Growable[R]) ⇒ L \/ R

Adds values into growables

      -\/(1).addTo(ints, strings)

ints += 1

\/-("foo").addTo(ints, strings)

strings += "foo"

removeFrom (L \/ R) GH

(L \/ R) ⇒ (Shrinkable[L], Shrinkable[R]) ⇒ L \/ R

Removes values from a shrinkables

      -\/(1).removeFrom(ints, strings)

ints -= 1

\/-("foo").removeFrom(ints, strings)

strings -= "foo"

leftFlatMap (L \/ R) GH

(L \/ R) ⇒ L => L \/ R => L \/ R

flatMap over the left, equivalent to swap.flatMap.swap

   \/-(123).leftFlatMap(in => in match { case "left" => \/-(100); case _ => -\/(in) }

\/-(123)

-\/("left").leftFlatMap(in => in match { case "left" => \/-(100); case _ => -\/(in) }

\/-(100)

 -\/("101").leftFlatMap(in => in match { case "left" => \/-(100); case _ => -\/(in) }

-\/("101")

fold Try[A] GH

Try[A] ⇒ (Throwable ⇒ B, A ⇒ B) ⇒ B

Convert to B

Failure(Throwable("boom")).fold(_.getMessage, "message: " + _)

"boom"

Success(123).fold(_.getMessage, "message: " + _)

"message: 123"

getMessage Try[A] GH

Try[A] ⇒ Option[String]

None if Success, Some if Failure

Failure(Throwable("boom")).getMessage

Some("boom")

Success(123).getMessage

None

toEither Try[A] GH

Try[A] ⇒ Either[Throwable, A]

Convert to Either

Failure(Throwable("boom")).toEither

Left(Throwable("boom"))

Success(123).toEither

Right(123)

toDisjunction Try[A] GH

Try[A] ⇒ Throwable \/ A

Convert to Disjunction

Failure(Throwable("boom")).toDisjunction

-\/(Throwable("boom"))

Success(123).toDisjunction

\/-(123)