stacycurl/pimpathon

Adds useful methods to scala & java classes.

pimpathon's Issues

Add Map pimps

valueForMaxKey, valueForMinKey, keyForMaxValue, keyForMinValue

Add MultiMap.select

def select(chooseValue: List[V] => V): Map[K, V]

Add RichAtomicReference

with some of the functionality from Shared.

Add any.applyAll

def applyAll(fns: (T ⇒ T)*): T = Function.chain(fns)(value)

Add Map.partitionKeysBy

def partitionBy[C](pf: PartialFunction[K, C]): (Map[C, V], Map[K, V])

pf: PartialFunction[K, C]

Add isOneOf & isNotOneOf to Any

Implement List.attributeCounts with a single pass

Add Map.sortByValues (sortValuesBy)

// Have to use map.get because even though we can safely call map.apply when sorting the map, the ordering is ALSO
// used to implement 'contains'
def sortByValues(implicit ordering: Ordering[V]): SortedMap[K, V] = sorted(Ordering.OptionV.on(map.get))

Add Map.andThenM

def andThenM[W](other: Map[V, W]): Map[K, W]

Option <=> Try

Add List.tailOption

Add RichPartialFunction.***

def ***[C, D](pf2: PartialFunction[C, D]): PartialFunction[(A, C), (B, D)]

Add Map.filterKeysNot

def filterKeysNot(f: K ⇒ Boolean): Map[K, V]

Add Map.filterValues

def filterValues(f: V ⇒ Boolean): Map[K, V]

Add PF variants of withSomeKeys & withSomeValues

Generalise withKeys withSomeKeys withPFKeys withManyKeys to withKeys[K[_]]

Add Map.getMany

def getMany(keys: List[K]): (List[V], List[K])

Add Any.compareTo

def compareTo(other : T)(implicit ev : Ordering[T]) = ev.compare(value, other)

CI goodness

Some notes on how we setup a nice workflow in ENSIME:

• get an account and setup https://travis-ci.org/stacycurl/pimpathon
• feel free to copy our travis config verbatim https://github.com/ensime/ensime-server/blob/master/.travis.yml and follow the instructions in the final two lines to insert your sonatype username/password. Also note that java6 is greatly preferred... you can cross-build for java7 but it will require some jiggery pokery to avoid publishing the java7 builds as well.
• you'll need https://github.com/ensime/ensime-server/blob/master/.check-diff.sh to enforce the formatting
• some nice plugins: https://github.com/ensime/ensime-server/blob/master/project/plugins.sbt
• https://github.com/ensime/ensime-server/blob/master/build.sbt#L58 to line 95 (and the relevant imports) will get you set up nicely with a lot of static analysis tools that the above travis config will enforce.
• be sad about scoverage/sbt-coveralls#18
• add lots of badges to your README

You'll need to temporarily comment out lines 4 and 5 of the travis config (enabling CI on other branches) until you have created those branches.

Repackage pimps to mirror package structure of pimped.

Add List.distinctBy

& maintain order

Add File.relativeTo

Option.getOrThrow

I often find myself wanting to use this pattern:

option.getOrElse(throw new IllegalArgumentException("some meaningful message"))

it would be great to be able to do

option.getOrThrow("some meaningful message")

perhaps with a String => Throwable curried parameter to allow users to change the kind of exception that is thrown (IAE default)

Add Either.tap

def tap[LV, RV](left: L => LV, right: R => RV): Either[L, R] = { either.fold(left, right); either }

Add Either[Throwable, R] <=> Try[R]

builds for 2.9.2, 2.9.3, 2.10 and 2.11

(sorry, 2.9 is a bitch, especially 2.9.2)

Add String.prefixWith

emptyTo, prefixWith, suffixWith, removePrefix, removeSuffix

Generalise MultiMap

Add RichInputStream

Add Predicate.ifSome

def ifSome: (Option[A]) ⇒ Boolean = (oa: Option[A]) ⇒ oa.fold(a ⇒ (f(a), false)

Add Map.collectKeys

def collectKeys[C](pf: PartialFunction[K, C]): Map[C, V]
def collectKeysO[C](f: K ⇒ Option[C]): Map[C, V]

Rich{File, InputStream, OutputStream}

these would be great.

Even better if convenience methods for creating File could be on the RichFile object itself and not a separate FileUtils.

Add RichOutputStream

Add Map.collectValues

def collectValues[W](pf: PartialFunction[V, W]): Map[K, W]
def collectValuesO[W](f: V ⇒ Option[W]): Map[K, W]

Add Map[K, V].flatMapKeys(K ⇒ GTL[C]): Map[C, V]

Add Map.sortKeysBy

def sortKeysBy[S](f: K ⇒ S)(implicit ordering: Ordering[S]): SortedMap[K, V]

Add RichManifest/RichClassTag

className[A: ClassTag]: String
simpleClassName[A: ClassTag]: String
klassOf[A: ClassTag]: Class[A]

Add Map.sorted

def sorted(implicit ordering: Ordering[K]): SortedMap[K, V]

Add to[Map] to[MultiMap] to[F[K, V]] to ListTuple2Ops

Add Map.contains(ok: Option[K])

Add Map.reverse

def reverse(chooseKey: Set[K] => K): Map[V, K]

change package name to plain pimpathon

in a shapeless-stylee it would be great if everything started with pimpathon instead of the longer stacycurl.scala.pimpathon

Add List.prefixPadTo

def prefixPadTo(len: Int, elem: A): List[A]

RichAny.withSideEffect

often called update, I find an explicit name is much easier to understand.

Add Map.reverseToMultiMap

Add Either.map

def map[LV, RV](left: L => LV, right: R => RV): Either[LV, RV] = either.fold(l => Left(left(l)), r => Right(right(r)))

Add Map.mapValuesEagerly

Add List.fraction

def fraction(pred: A ⇒ Boolean): Double

Add Map.get(ok: Option[K]): Option[v]

Add Traversable pimps

def attributeCounts[B](f: A => B): Map[B, Int]
def optAttributeCounts[B](f: A => Option[B]): Map[B, Int]
def collectAttributeCounts[B](pf: PartialFunction[A, B]): Map[B, Int]