Add helpers for manipulating Range and NumericRange

Mostly growing and shrinking the ranges

Author: morgen-peschke

build.sc

@@ -107,21 +107,26 @@ class CoreModule(val crossScalaVersion: String) extends CommonModule {
 
 object collections extends Cross[CollectionsModule](Scala12, Scala13)
 class CollectionsModule(val crossScalaVersion: String) extends CommonModule {
+ override def ivyDeps: T[Agg[Dep]] = super.ivyDeps() ++ Agg(CatsCore)
+
  object test extends Tests with CommonTestModule {
  override def moduleDeps: Seq[JavaModule] =
  super.moduleDeps ++ Seq(scalacheck(crossScalaVersion))
 
  override def crossScalaVersion: String = outerCrossScalaVersion
 
- override def ivyDeps: T[Agg[Dep]] = super.ivyDeps() ++ Agg.from(WordSpec)
+ override def ivyDeps: T[Agg[Dep]] = super.ivyDeps() ++ Agg.from(WordSpec ++ PropSpec)
  }
 }
 
 object scalacheck extends Cross[ScalaCheckModule](Scala12, Scala13)
 class ScalaCheckModule(val crossScalaVersion: String) extends CommonModule {
  override def ivyDeps: T[Agg[Dep]] = super.ivyDeps() ++ Agg(ScalaCheck)
 
- override def moduleDeps: Seq[PublishModule] = super.moduleDeps ++ Seq(core(crossScalaVersion))
+ override def moduleDeps: Seq[PublishModule] = super.moduleDeps ++ Seq(
+ core(crossScalaVersion),
+ collections(crossScalaVersion)
+ )
 
  object test extends Tests with CommonTestModule {
  override def crossScalaVersion: String = outerCrossScalaVersion

collections/src/peschke/collections/range/RangeUtils.scala

@@ -0,0 +1,151 @@
+package peschke.collections.range
+
+import scala.collection.immutable.NumericRange
+
+object RangeUtils {
+
+ private def copy
+ (range: Range)
+ (start: Int = range.start, end: Int = range.end, step: Int = range.step) // scalafix:ok DisableSyntax.defaultArgs
+ : Range =
+ if (range.isInclusive) Range.inclusive(start, end, step)
+ else Range(start, end, step)
+
+ private def copyNumeric[N]
+ (range: NumericRange[N])
+ (start: N = range.start, end: N = range.end, step: N = range.step) // scalafix:ok DisableSyntax.defaultArgs
+ (implicit I: Integral[N])
+ : NumericRange[N] =
+ if (range.isInclusive) NumericRange.inclusive(start, end, step)
+ else NumericRange(start, end, step)
+
+ /** The inverse of [[Range.drop]]
+ *
+ * Extends the range start such that `range.grow(n).drop(n) == range`
+ */
+ def grow(range: Range, steps: Int): Range =
+ if (steps <= 0) range
+ else copy(range)(start = range.start - (range.step * steps))
+
+ /** The inverse of [[Range.dropRight]]
+ *
+ * Extends the range end such that `range.growRight(n).dropRight(n) == range`
+ */
+ def growRight(range: Range, steps: Int): Range =
+ if (steps <= 0) range
+ else copy(range)(end = range.end + (range.step * steps))
+
+ /** Shift the entire range by a number of steps
+ *
+ * Equivalent to `range.growRight(n).drop(n)`
+ *
+ * Note: with the exception of situations where intermediate values would
+ * overflow or underflow, [[shift]] and [[unshift]] are inverse operations
+ */
+ def shift(range: Range, steps: Int): Range =
+ if (steps <= 0) range
+ else {
+ val offset = range.step * steps
+ copy(range)(
+ start = range.start + offset,
+ end = range.end + offset
+ )
+ }
+
+ /** Shift the entire range by a number of steps
+ *
+ * Equivalent to `range.grow(n).dropRight(n)`, and the inverse of [[shift]]
+ */
+ def unshift(range: Range, steps: Int): Range =
+ if (steps <= 0) range
+ else {
+ val offset = range.step * steps
+ copy(range)(
+ start = range.start - offset,
+ end = range.end - offset
+ )
+ }
+
+ /** Specialization of [[NumericRange.slice]], returning a [[NumericRange]]
+ * instead of an [[IndexedSeq]]
+ *
+ * Equivalent to `r.drop(from).take(until - from)`
+ */
+ def sliceNumeric[N](range: NumericRange[N], from: Int, until: Int)
+ (implicit I: Integral[N])
+ : NumericRange[N] =
+ if (from <= 0) range.take(until)
+ else if (until >= range.length) range.drop(from)
+ else {
+ val fromValue = I.plus(range.start, I.times(range.step, I.fromInt(from)))
+
+ def untilValue =
+ I.plus(range.start, I.times(range.step, I.fromInt(until - 1)))
+
+ if (from >= until) NumericRange(fromValue, fromValue, range.step)
+ else NumericRange.inclusive(fromValue, untilValue, range.step)
+ }
+
+ /** The inverse of [[NumericRange.drop]]
+ *
+ * Extends the range start such that `range.grow(n).drop(n) == range`
+ */
+ def growNumeric[N](range: NumericRange[N], steps: Int)
+ (implicit I: Integral[N])
+ : NumericRange[N] =
+ if (steps <= 0) range
+ else
+ copyNumeric(range)(start =
+ I.minus(range.start, I.times(range.step, I.fromInt(steps)))
+ )
+
+ /** The inverse of [[NumericRange.dropRight]]
+ *
+ * Extends the range end such that `range.growRight(n).dropRight(n) == range`
+ */
+ def growNumericRight[N](range: NumericRange[N], steps: Int)
+ (implicit I: Integral[N])
+ : NumericRange[N] =
+ if (steps <= 0) range
+ else
+ copyNumeric(range)(end =
+ I.plus(range.end, I.times(range.step, I.fromInt(steps)))
+ )
+
+ /** Shift the entire range by a number of steps
+ *
+ * Equivalent to `range.drop(n).growRight(n)`
+ *
+ * Note: with the exception of situations where intermediate values would
+ * overflow or underflow, [[shiftNumeric]] and [[unshiftNumeric]] are inverse
+ * operations
+ */
+ def shiftNumeric[N](range: NumericRange[N], steps: Int)
+ (implicit I: Integral[N])
+ : NumericRange[N] =
+ if (steps <= 0) range
+ else {
+ val offset = I.times(range.step, I.fromInt(steps))
+ copyNumeric(range)(
+ start = I.plus(range.start, offset),
+ end = I.plus(range.end, offset)
+ )
+ }
+
+ /** Shift the entire range by a number of steps
+ *
+ * Equivalent to `range.dropRight(n).grow(n)`, and the inverse of
+ * [[shiftNumeric]]
+ */
+ def unshiftNumeric[N](range: NumericRange[N], steps: Int)
+ (implicit I: Integral[N])
+ : NumericRange[N] =
+ if (steps <= 0) range
+ else {
+ val offset = I.times(range.step, I.fromInt(steps))
+ copyNumeric(range)(
+ start = I.minus(range.start, offset),
+ end = I.minus(range.end, offset)
+ )
+ }
+}

collections/src/peschke/collections/range/syntax.scala

@@ -0,0 +1,84 @@
+package peschke.collections.range
+
+import scala.collection.immutable.NumericRange
+
+object syntax {
+ implicit final class ScalaCommonsRangeOps(private val range: Range)
+ extends AnyVal {
+
+ /** The inverse of [[Range.drop]]
+ *
+ * @see
+ * [[RangeUtils.grow]]
+ */
+ def grow(steps: Int): Range = RangeUtils.grow(range, steps)
+
+ /** The inverse of [[Range.dropRight]]
+ *
+ * @see
+ * [[RangeUtils.growRight]]
+ */
+ def growRight(steps: Int): Range = RangeUtils.growRight(range, steps)
+
+ /** Shift the entire range by a number of steps
+ *
+ * @see
+ * [[RangeUtils.shift]]
+ */
+ def shift(steps: Int): Range = RangeUtils.shift(range, steps)
+
+ /** Shift the entire range by a number of steps
+ *
+ * @see
+ * [[RangeUtils.unshift]]
+ */
+ def unshift(steps: Int): Range = RangeUtils.unshift(range, steps)
+ }
+
+ implicit final class ScalaCommonsNumericRangeOps[N]
+ (private val range: NumericRange[N])
+ extends AnyVal {
+
+ /** Specialization of [[NumericRange.slice]], returning a [[NumericRange]]
+ * instead of an [[IndexedSeq]]
+ *
+ * @see
+ * [[RangeUtils.shiftNumeric]]
+ */
+ def sliceRange(from: Int, until: Int)(implicit I: Integral[N])
+ : NumericRange[N] =
+ RangeUtils.sliceNumeric(range, from, until)
+
+ /** The inverse of [[NumericRange.drop]]
+ *
+ * @see
+ * [[RangeUtils.growNumeric]]
+ */
+ def grow(steps: Int)(implicit I: Integral[N]): NumericRange[N] =
+ RangeUtils.growNumeric(range, steps)
+
+ /** The inverse of [[NumericRange.dropRight]]
+ *
+ * @see
+ * [[RangeUtils.growNumericRight]]
+ */
+ def growRight(steps: Int)(implicit I: Integral[N]): NumericRange[N] =
+ RangeUtils.growNumericRight(range, steps)
+
+ /** Shift the entire range by a number of steps
+ *
+ * @see
+ * [[RangeUtils.shiftNumeric]]
+ */
+ def shift(steps: Int)(implicit I: Integral[N]): NumericRange[N] =
+ RangeUtils.shiftNumeric(range, steps)
+
+ /** Shift the entire range by a number of steps
+ *
+ * @see
+ * [[RangeUtils.unshiftNumeric]]
+ */
+ def unshift(steps: Int)(implicit I: Integral[N]): NumericRange[N] =
+ RangeUtils.unshiftNumeric(range, steps)
+ }
+}

collections/test/src/peschke/UnitSpec.scala

@@ -1,12 +1,24 @@
 package peschke
 
+import org.scalacheck.Shrink
 import org.scalatest.EitherValues
 import org.scalatest.OptionValues
 import org.scalatest.matchers.must.Matchers
+import org.scalatest.propspec.AnyPropSpec
 import org.scalatest.wordspec.AnyWordSpec
+import org.scalatestplus.scalacheck.ScalaCheckDrivenPropertyChecks
 
 trait UnitSpec
  extends AnyWordSpec
  with Matchers
  with EitherValues
  with OptionValues
+
+trait PropSpec
+ extends AnyPropSpec
+ with Matchers
+ with EitherValues
+ with OptionValues
+ with ScalaCheckDrivenPropertyChecks {
+ implicit def noShrink[A]: Shrink[A] = Shrink.shrinkAny
+}