Slice notation in Scala?
Equivalent method in Scala (with a slightly different syntax) exists for all kinds of sequences:
scala> "Hello world" slice(0,4)res0: String = Hellscala> (1 to 10) slice(3,5)res1: scala.collection.immutable.Range = Range(4, 5)
The biggest difference compared to slicing in Python is that start and end indices are mandatory in Scala.
scala> import collection.IterableLikeimport collection.IterableLikescala> implicit def pythonicSlice[A, Repr](coll: IterableLike[A, Repr]) = new { | def apply(subrange: (Int, Int)): Repr = coll.slice(subrange._1, subrange._2) | }pythonicSlice: [A,Repr](coll: scala.collection.IterableLike[A,Repr])java.lang.Object{def apply(subrange: (Int, Int)): Repr}scala> val list = List(3, 4, 11, 78, 3, 9)list: List[Int] = List(3, 4, 11, 78, 3, 9)scala> list(2 -> 5)res4: List[Int] = List(11, 78, 3)
Will this do?
Disclaimer: Not properly generalized.
EDIT:
scala> case class PRange(start: Int, end: Int, step: Int = 1)defined class PRangescala> implicit def intWithTildyArrow(i: Int) = new { | def ~>(j: Int) = PRange(i, j) | }intWithTildyArrow: (i: Int)java.lang.Object{def ~>(j: Int): PRange}scala> implicit def prangeWithTildyArrow(p: PRange) = new { | def ~>(step: Int) = p.copy(step = step) | }prangeWithTildyArrow: (p: PRange)java.lang.Object{def ~>(step: Int): PRange}scala> implicit def pSlice[A](coll: List[A]) = new { | def apply(prange: PRange) = { | import prange._ | coll.slice(start, end).grouped(step).toList.map(_.head) | } | }pSlice: [A](coll: List[A])java.lang.Object{def apply(prange: PRange): List[A]}scala> val xs = List.range(1, 10)xs: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)scala> xs(3 ~> 9)res32: List[Int] = List(4, 5, 6, 7, 8, 9)scala> xs(3 ~> 9 ~> 2)res33: List[Int] = List(4, 6, 8)
See the ScalaAPI here
So not the same notational convenience, but the operation is there
def slice (from: Int, until: Int) : Seq[A]
Selects an interval of elements.
Selects an interval of elements.
Note: c.slice(from, to) is equivalent to (but possibly more efficient than) c.drop(from).take(to - from)
from the index of the first returned element in this sequence. until the index one past the last returned element in this sequence.
returns
a sequence containing the elements starting at index from and extending up to (but not including) index until of this sequence.
definition classes: IterableLike → TraversableLike