final class IArray[A] extends AnyVal
- Source
- IArray.scala
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- IArray
- AnyVal
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- Any
- final def ##: Int
- Definition Classes
- Any
- def ++(that: IArray[A]): IArray[A]
scala> IArray("a", "b", "c") ++ IArray("x", "y") res0: IArray[String] = IArray(a, b, c, x, y)
Example: - def +:(a: A): IArray[A]
scala> 100 +: IArray(1, 2, 3) res0: IArray[Int] = IArray(100, 1, 2, 3)
Example: - def :+(a: A): IArray[A]
scala> IArray(1, 2, 3) :+ 100 res0: IArray[Int] = IArray(1, 2, 3, 100)
Example: - final def ==(arg0: Any): Boolean
- Definition Classes
- Any
- def ===(that: IArray[A])(implicit A: Equal[A]): Boolean
scala> import scalaz.std.anyVal._ scala> IArray(1, 2) === IArray(1, 2) res0: Boolean = true
Example: - def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
scala> IArray("x", "y", "z").addString(new StringBuilder("aaa"), "c", "d", "e").toString res0: String = aaacxdydze
Example: - def align[B](b: IArray[B]): IArray[\&/[A, B]]
scala> import scalaz.\&/ scala> IArray(1, 2, 3) align IArray("a", "b", "c", "d", "e") res0: IArray[Int \&/ String] = IArray(Both(1,a), Both(2,b), Both(3,c), That(d), That(e))
Example: - def alignWith[B, C](that: IArray[B])(f: (\&/[A, B]) => C): IArray[C]
scala> res0: =
Example: - def apply(i: Int): A
- Annotations
- @inline()
scala> val x = IArray(10, 20, 30, 40) scala> x(2) res0: Int = 30
Example: - final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cobind[B](f: (IArray[A]) => B): IArray[B]
scala> res0: =
Example: - def cojoin: IArray[IArray[A]]
scala> res0: =
Example: - def collect[B](f: PartialFunction[A, B]): IArray[B]
scala> IArray(1, 2, 3, 4, 5, 6, 7).collect{ case i if i > 3 => i * 10 } res0: IArray[Int] = IArray(40, 50, 60, 70)
Example: - def collectBy[B](implicit B: ClassTag[B]): IArray[B]
scala> IArray[Seq[Int]](Vector(1), List(2), Vector(3), List(4)).collectBy[Vector[Int]] res0: IArray[Vector[Int]] = IArray(Vector(1), Vector(3))
Example: - def collectFirst[B](f: PartialFunction[A, B]): Option[B]
scala> IArray(1, 2, 3, 4, 5, 6, 7).collectFirst{ case i if i > 3 => i * 10 } res0: Option[Int] = Some(40)
Example: - def collectLast[B](f: PartialFunction[A, B]): Option[B]
scala> IArray(1, 2, 3, 4, 5, 6, 7).collectLast{ case i if i < 3 => i * 10 } res0: Option[Int] = Some(20)
Example: - def contains(a: A)(implicit A: Equal[A]): Boolean
scala> import scalaz.std.anyVal._ scala> val a = IArray(1, 2, 3, 4) scala> a.contains(3) res0: Boolean = true scala> a.contains(5) res1: Boolean = false
Example: - def count(f: (A) => Boolean): Int
scala> IArray(1, 2, 3, 4, 5, 6, 7).count(_ % 2 == 1) res0: Int = 4
Example: - def dropL(n: Int): IArray[A]
scala> val a = IArray("a", "b", "c", "d", "e") scala> a.dropL(-1) res0: IArray[String] = IArray(a, b, c, d, e) scala> a.dropL(2) res1: IArray[String] = IArray(c, d, e) scala> a.dropL(6) res2: IArray[String] = IArray()
Example: - def dropR(n: Int): IArray[A]
scala> val a = IArray("a", "b", "c", "d", "e") scala> a.dropR(-1) res0: IArray[String] = IArray(a, b, c, d, e) scala> a.dropR(2) res1: IArray[String] = IArray(a, b, c) scala> a.dropR(6) res2: IArray[String] = IArray()
Example: - def dropWhileL(f: (A) => Boolean): IArray[A]
scala> IArray(1, 2, 3, 4, 5, 6, 7).dropWhileL(_ < 4) res0: IArray[Int] = IArray(4, 5, 6, 7)
Example: - def dropWhileR(f: (A) => Boolean): IArray[A]
scala> IArray(1, 2, 3, 4, 5, 6, 7).dropWhileR(_ > 5) res0: IArray[Int] = IArray(1, 2, 3, 4, 5)
Example: - def endsWith(that: IArray[A])(implicit A: Equal[A]): Boolean
scala> import scalaz.std.anyVal._ scala> IArray(1, 2, 3, 4, 5) endsWith IArray(3, 4, 5) res0: Boolean = true
Example: - def exists(f: (A) => Boolean): Boolean
scala> val a = IArray(1, 2, 3, 4) scala> a.exists(_ % 3 == 0) res0: Boolean = true scala> a.exists(_ <= 0) res1: Boolean = false
Example: - def filter(f: (A) => Boolean): IArray[A]
scala> IArray(1, 2, 3, 4, 5).filter(_ % 3 != 1) res0: IArray[Int] = IArray(2, 3, 5)
Example: - def find(f: (A) => Boolean): Option[A]
scala> IArray(1, 2, 3, 4, 5).find(_ > 3) res0: Option[Int] = Some(4)
Example: - def findRight(f: (A) => Boolean): Option[A]
scala> IArray(1, 2, 3, 4, 5).findRight(_ < 4) res0: Option[Int] = Some(3)
Example: - def firsts[B, C](implicit e: <:<[A, Product2[B, C]]): IArray[B]
scala> IArray(("a", 1), ("b", 2)).firsts res0: IArray[String] = IArray(a, b)
Example: - def flatMap[B](f: (A) => IArray[B]): IArray[B]
scala> IArray("ab", "cde").flatMap(IArray.from(_)) res0: IArray[Char] = IArray(a, b, c, d, e)
Example: - def flatten[B](implicit A: <:<[A, IArray[B]]): IArray[B]
scala> IArray(IArray(1, 2), IArray(3)).flatten res0: IArray[Int] = IArray(1, 2, 3)
Example: - def fold(implicit A: Monoid[A]): A
scala> import scalaz.std.anyVal._ scala> IArray(1, 2, 3, 4, 5).fold res0: Int = 15 scala> import scalaz.std.string._ scala> IArray("a", "bc", "d").fold res1: String = abcd
Example: - def fold1Opt(implicit A: Semigroup[A]): Option[A]
scala> import scalaz.{\/, \/-, -\/} scala> import scalaz.std.string._, scalaz.std.anyVal._ scala> IArray[Int \/ String](\/-("a"), -\/(1), -\/(2), \/-("b")).fold1Opt res0: Option[Int \/ String] = Some(-\/(3)) scala> IArray.empty[Int \/ String].fold1Opt res1: Option[Int \/ String] = None
Example: - def foldMap[B](f: (A) => B)(implicit B: Monoid[B]): B
scala> import scalaz.std.anyVal._ scala> IArray(123, 23, 9, 54).foldMap(_.toString.size) res0: Int = 8
Example: - def foldMap1Opt[B](f: (A) => B)(implicit B: Semigroup[B]): Option[B]
scala> res0: =
Example: - def foldMapL1[B](z: (A) => B)(f: (B, A) => B): Option[B]
scala> res0: =
Example: - def foldMapR1Opt[B](z: (A) => B)(f: (A, B) => B): Option[B]
scala> res0: =
Example: - def foldl[B](z: B)(f: (B, A) => B): B
scala> res0: =
Example: - def foldl1(f: (A, A) => A): Option[A]
scala> res0: =
Example: - def foldr[B](z: B)(f: (A, B) => B): B
scala> res0: =
Example: - def foldr1(f: (A, A) => A): Option[A]
scala> res0: =
Example: - def forall(f: (A) => Boolean): Boolean
scala> val a = IArray(1, 2, 3, 4) scala> a.forall(_ <= 4) res0: Boolean = true scala> a.forall(_ % 4 < 3) res1: Boolean = false
Example: - def foreach[U](f: (A) => U): Unit
scala> res0: =
Example: - def getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- def groupBy1[B](f: (A) => B)(implicit O: Order[B]): ==>>[B, IArray1[A]]
scala> import scalaz.std.anyVal._ scala> IArray(1, 2, 3, 4, 5).groupBy1(_ % 3).toList.sortBy(_._1) res0: List[(Int, IArray1[Int])] = List((0,IArray1(3)), (1,IArray1(1, 4)), (2,IArray1(2, 5)))
Example: - def headMaybe: Maybe[A]
scala> IArray(10, 20, 30).headMaybe res0: scalaz.Maybe[Int] = Just(10)
Example: - def headOption: Option[A]
scala> IArray(10, 20, 30).headOption res0: Option[Int] = Some(10)
Example: - def indexOfL(a: A)(implicit E: Equal[A]): Option[Int]
scala> import scalaz.std.anyVal._ scala> IArray(-1, 0, 1, 2, -1, 0, 1, 2).indexOfL(2) res0: Option[Int] = Some(3) scala> IArray(1, 2, 3, 1, 2, 3).indexOfL(5) res1: Option[Int] = None
Example: - def indexOfR(a: A)(implicit E: Equal[A]): Option[Int]
scala> import scalaz.std.anyVal._ scala> IArray(1, 2, 3, 1, 2, 3).indexOfR(1) res0: Option[Int] = Some(3) scala> IArray(1, 2, 3, 1, 2, 3).indexOfR(5) res1: Option[Int] = None
Example: - def initMaybe: Maybe[IArray[A]]
scala> IArray(10, 20, 30).initMaybe res0: scalaz.Maybe[IArray[Int]] = Just(IArray(10, 20))
Example: - def initOption: Option[IArray[A]]
scala> IArray(10, 20, 30).initOption res0: Option[IArray[Int]] = Some(IArray(10, 20))
Example: - def intercalate(a: A)(implicit A: Monoid[A]): A
scala> import scalaz.std.list._ scala> IArray(List("a"), List("b", "c"), Nil, List("d")).intercalate(List("z")) res0: List[String] = List(a, z, b, c, z, z, d)
Example: - def intercalate1Opt(a: A)(implicit A: Semigroup[A]): Option[A]
scala> import scalaz.std.list._ scala> IArray(List("a"), List("b", "c"), Nil, List("d")).intercalate1Opt(List("z")) res0: Option[List[String]] = Some(List(a, z, b, c, z, z, d)) scala> IArray.empty[List[Int]].intercalate1Opt(List(7)) res1: Option[List[Int]] = None
Example: - def interleave(that: IArray[A]): IArray[A]
- def intersperse(a: A): IArray[A]
scala> IArray(1, 2, 3, 4).intersperse(0) res0: IArray[Int] = IArray(1, 0, 2, 0, 3, 0, 4)
Example: - def isEmpty: Boolean
- Annotations
- @inline()
scala> IArray(1, 2).isEmpty res0: Boolean = false scala> IArray[Int](1, 2).dropL(10).isEmpty res1: Boolean = true
Example: - final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def lastMaybe: Maybe[A]
scala> IArray(10, 20, 30).lastMaybe res0: scalaz.Maybe[Int] = Just(30)
Example: - def lastOption: Option[A]
scala> IArray(10, 20, 30).lastOption res0: Option[Int] = Some(30)
Example: - def length: Int
- Annotations
- @inline()
scala> IArray("a", "b").length res0: Int = 2
Example: - def map[B](f: (A) => B): IArray[B]
scala> IArray(1, 2, 3).map(_ * 10) res0: IArray[Int] = IArray(10, 20, 30)
Example: - def mapAccumL[S, B](z: S)(f: (S, A) => (S, B)): (S, IArray[B])
scala> res0: =
Example: - def mapAccumR[S, B](z: S)(f: (S, A) => (S, B)): (S, IArray[B])
scala> res0: =
Example: - def max(implicit O: Order[A]): Option[A]
scala> import scalaz.std.anyVal._ scala> IArray(20, 30, 10).max res0: Option[Int] = Some(30) scala> IArray[Int]().max res1: Option[Int] = None
Example: - def maxBy[B](f: (A) => B)(implicit O: Order[B]): Option[A]
scala> import scalaz.std.anyVal._ scala> IArray("aa", "bbb", "c").maxBy(_.size) res0: Option[String] = Some(bbb) scala> IArray[String]().maxBy(_.size) res1: Option[String] = None
Example: - def maxOf[B](f: (A) => B)(implicit O: Order[B]): Option[B]
scala> import scalaz.std.anyVal._ scala> IArray(20, 30, 10).maxOf(- _) res0: Option[Int] = Some(-10) scala> IArray[Int]().maxOf(- _) res1: Option[Int] = None
Example: - def min(implicit O: Order[A]): Option[A]
scala> import scalaz.std.anyVal._ scala> IArray(20, 30, 10).min res0: Option[Int] = Some(10) scala> IArray[Int]().min res1: Option[Int] = None
Example: - def minBy[B](f: (A) => B)(implicit O: Order[B]): Option[A]
scala> import scalaz.std.anyVal._ scala> IArray("aa", "bbb", "c").minBy(_.size) res0: Option[String] = Some(c) scala> IArray[String]().minBy(_.size) res1: Option[String] = None
Example: - def minOf[B](f: (A) => B)(implicit O: Order[B]): Option[B]
scala> import scalaz.std.anyVal._ scala> IArray(20, 30, 10).minOf(- _) res0: Option[Int] = Some(-30) scala> IArray[Int]().minOf(- _) res1: Option[Int] = None
Example: - def mkString(start: String, sep: String, end: String): String
scala> IArray(1, 2, 3).mkString("[", ",", "]") res0: String = [1,2,3]
Example: - def mkString(sep: String = ""): String
scala> IArray("a", "b", "c").mkString("_") res0: String = a_b_c
Example: - def nonEmpty: Boolean
- Annotations
- @inline()
scala> IArray(1, 2).nonEmpty res0: Boolean = true scala> IArray[Int](1, 2).dropL(10).nonEmpty res1: Boolean = false
Example: - def oneAnd: Option[OneAnd[IArray, A]]
scala> IArray(1, 2, 3).oneAnd res0: Option[scalaz.OneAnd[IArray, Int]] = Some(OneAnd(1,IArray(2, 3)))
Example: - def partition(f: (A) => Boolean): (IArray[A], IArray[A])
scala> IArray(2, 8, 11, -2, 5, 6).partition(_ % 2 == 0) res0: (IArray[Int], IArray[Int]) = (IArray(2, 8, -2, 6),IArray(11, 5))
Example: - def reverse: IArray[A]
scala> IArray(1, 2, 3).reverse res0: IArray[Int] = IArray(3, 2, 1)
Example: - def reverseArray(implicit A: ClassTag[A]): Array[A]
scala> IArray(1, 2, 3).reverseArray res0: Array[Int] = Array(3, 2, 1)
Example: - def reverseIList: IList[A]
scala> IArray(1, 2, 3).reverseIList res0: scalaz.IList[Int] = [3,2,1]
Example: - def reverseList: List[A]
scala> IArray(1, 2, 3).reverseList res0: List[Int] = List(3, 2, 1)
Example: - def reverseMap[B](f: (A) => B): IArray[B]
scala> IArray(1, 2, 3, 4).reverseMap(_ * 3) res0: IArray[Int] = IArray(12, 9, 6, 3)
Example: - def reverse_:::(prefix: IArray[A]): IArray[A]
scala> IArray(1, 2, 3) reverse_::: IArray(10, 11, 12) res0: IArray[Int] = IArray(3, 2, 1, 10, 11, 12)
Example: - def scanLeft[B](z: B)(f: (B, A) => B): IArray[B]
scala> res0: =
Example: - def scanLeft1(f: (A, A) => A): IArray[A]
scala> res0: =
Example: - def scanRight[B](z: B)(f: (A, B) => B): IArray[B]
scala> res0: =
Example: - def scanRight1(f: (A, A) => A): IArray[A]
scala> res0: =
Example: - def seconds[B, C](implicit e: <:<[A, Product2[B, C]]): IArray[C]
scala> IArray(("a", 10), ("b", 20)).seconds res0: IArray[Int] = IArray(10, 20)
Example: - def size: Int
- Annotations
- @inline()
- def slice(from: Int, until: Int): IArray[A]
scala> val array = IArray("a", "b", "c", "d", "e", "f") scala> array.slice(1, 3) res0: IArray[String] = IArray(b, c) scala> array.slice(4, 17) res1: IArray[String] = IArray(e, f)
Example: - def sortBy[B](f: (A) => B)(implicit O: Order[B]): IArray[A]
scala> import scalaz.std.anyVal._ scala> IArray("aaaa", "bb", "ccccc", "d").sortBy(_.length) res0: IArray[String] = IArray(d, bb, aaaa, ccccc)
Example: - def sortWith(f: (A, A) => Boolean): IArray[A]
scala> IArray(2, 7, 4, 6, 1).sortWith(_ > _) res0: IArray[Int] = IArray(7, 6, 4, 2, 1)
Example: - def sorted(implicit O: Order[A]): IArray[A]
scala> import scalaz.std.string._ scala> IArray("y", "k", "f", "i", "t", "s").sorted res0: IArray[String] = IArray(f, i, k, s, t, y)
Example: - def span(f: (A) => Boolean): (IArray[A], IArray[A])
scala> IArray(2, 8, 11, -2, 5, 6).span(_ % 2 == 0) res0: (IArray[Int], IArray[Int]) = (IArray(2, 8),IArray(11, -2, 5, 6))
Example: - def splitAt(n: Int): (IArray[A], IArray[A])
scala> IArray(10, 20, 30, 40, 50, 60, 70).splitAt(5) res0: (IArray[Int], IArray[Int]) = (IArray(10, 20, 30, 40, 50),IArray(60, 70))
Example: - def startsWith(that: IArray[A], offset: Int = 0)(implicit A: Equal[A]): Boolean
scala> import scalaz.std.anyVal._ scala> IArray(1, 2, 3, 4, 5) startsWith IArray(1, 2) res0: Boolean = true
Example: - def sum(implicit A: Numeric[A]): A
scala> IArray(10, 20, 30).sum res0: Int = 60
Example: - def tailMaybe: Maybe[IArray[A]]
scala> IArray(10, 20, 30).tailMaybe res0: scalaz.Maybe[IArray[Int]] = Just(IArray(20, 30))
Example: - def tailOption: Option[IArray[A]]
scala> IArray(10, 20, 30).tailOption res0: Option[IArray[Int]] = Some(IArray(20, 30))
Example: - def takeL(n: Int): IArray[A]
scala> IArray("a", "b", "c", "d", "e", "f").takeL(2) res0: IArray[String] = IArray(a, b)
Example: - def takeR(n: Int): IArray[A]
scala> IArray("a", "b", "c", "d", "e", "f").takeR(4) res0: IArray[String] = IArray(c, d, e, f)
Example: - def takeWhileL(f: (A) => Boolean): IArray[A]
scala> IArray(1, 2, 3, 4, 5, 6, 7).takeWhileL(_ < 5) res0: IArray[Int] = IArray(1, 2, 3, 4)
Example: - def takeWhileR(f: (A) => Boolean): IArray[A]
scala> IArray(1, 2, 3, 4, 5, 6, 7).takeWhileR(_ > 2) res0: IArray[Int] = IArray(3, 4, 5, 6, 7)
Example: - def toArray(implicit A: ClassTag[A]): Array[A]
scala> IArray(1, 2, 3).toArray res0: Array[Int] = Array(1, 2, 3)
Example: - def toIArray1: Option[IArray1[A]]
scala> IArray(1, 2, 3).toIArray1 res0: Option[IArray1[Int]] = Some(IArray1(1, 2, 3)) scala> IArray[Int]().toIArray1 res1: Option[IArray1[Int]] = None
Example: - def toIList: IList[A]
scala> IArray(1, 2, 3).toIList res0: scalaz.IList[Int] = [1,2,3]
Example: - def toIterator: Iterator[A]
scala> IArray(1, 2, 3, 4, 5).toIterator.filter(_ % 2 == 0).toList res0: List[Int] = List(2, 4)
Example: - def toList: List[A]
scala> IArray(1, 2, 3).toList res0: List[Int] = List(1, 2, 3)
Example: - def toNel: Option[NonEmptyList[A]]
scala> import scalaz.NonEmptyList scala> IArray(1, 2, 3).toNel res0: Option[NonEmptyList[Int]] = Some(NonEmpty[1,2,3]) scala> IArray[Int]().toNel res1: Option[NonEmptyList[Int]] = None
Example: - def toStream: Stream[A]
- def toString(): String
- Definition Classes
- IArray → Any
scala> IArray(1, 2, 3).toString res0: String = IArray(1, 2, 3)
Example: - def toVector: Vector[A]
- def unzip[B, C](implicit e: <:<[A, Product2[B, C]]): (IArray[B], IArray[C])
alias of
unzip2
- def unzip2[B, C](implicit e: <:<[A, Product2[B, C]]): (IArray[B], IArray[C])
scala> IArray(("a", 1), ("b", 2)).unzip2 res0: (IArray[String], IArray[Int]) = (IArray(a, b),IArray(1, 2))
Example: - def unzip3[B, C, D](implicit e: <:<[A, Product3[B, C, D]]): (IArray[B], IArray[C], IArray[D])
scala> IArray(("a", 1, true), ("b", 2, false)).unzip3 res0: (IArray[String], IArray[Int], IArray[Boolean]) = (IArray(a, b),IArray(1, 2),IArray(true, false))
Example: - def unzip4[B, C, D, E](implicit e: <:<[A, Product4[B, C, D, E]]): (IArray[B], IArray[C], IArray[D], IArray[E])
scala> IArray(("a", 1, true, List(3)), ("b", 2, false, List(4))).unzip4 res0: (IArray[String], IArray[Int], IArray[Boolean], IArray[List[Int]]) = (IArray(a, b),IArray(1, 2),IArray(true, false),IArray(List(3), List(4)))
Example: - def unzip5[B, C, D, E, F](implicit e: <:<[A, Product5[B, C, D, E, F]]): (IArray[B], IArray[C], IArray[D], IArray[E], IArray[F])
scala> IArray(("a", 1, true, List(3), 'f'), ("b", 2, false, List(4), 'g')).unzip5 res0: (IArray[String], IArray[Int], IArray[Boolean], IArray[List[Int]], IArray[Char]) = (IArray(a, b),IArray(1, 2),IArray(true, false),IArray(List(3), List(4)),IArray(f, g))
Example: - def updated(index: Int, elem: A): IArray[A]
- Annotations
- @throws(scala.this.throws.<init>$default$1[IndexOutOfBoundsException])
scala> IArray("a", "b", "c", "d").updated(2, "z") res0: IArray[String] = IArray(a, b, z, d)
Example: - def widen[B](implicit ev: <:<[A, B]): IArray[B]
scala> IArray(List(1)).widen[Seq[Int]] res0: IArray[Seq[Int]] = IArray(List(1))
Example: - def withFilter(f: (A) => Boolean): WithFilter[A]
scala> IArray(1, 2, 3, 4, 5).withFilter(_ % 3 != 1).map(_ * 10) res0: IArray[Int] = IArray(20, 30, 50)
Example: - def withIndex: WithIndex[A]
scala> res0: =
Example: - def zip[B](that: IArray[B]): IArray[(A, B)]
scala> IArray("a", "b") zip IArray(1, 2, 3, 4) res0: IArray[(String, Int)] = IArray((a,1), (b,2))
Example: - def zipAll[B](that: IArray[B], a: A, b: B): IArray[(A, B)]
scala> IArray("a", "b", "c", "d").zipAll(IArray(1, 2), "z", 0) res0: IArray[(String, Int)] = IArray((a,1), (b,2), (c,0), (d,0))
Example: - def zipWith[B, C](that: IArray[B])(f: (A, B) => C): IArray[C]
scala> IArray("a", "b", "c", "d").zipWith(IArray("x", "y", "z"))(_ + _) res0: IArray[String] = IArray(ax, by, cz)
Example: - def zipWithIndex: IArray[(A, Int)]
scala> IArray("a", "b", "c").zipWithIndex res0: IArray[(String, Int)] = IArray((a,0), (b,1), (c,2))
Example: - def zipperEnd: Option[Zipper[A]]
scala> IArray(1, 2, 3).zipperEnd.map(_.modify(_ + 10).toStream.toList) res0: Option[List[Int]] = Some(List(1, 2, 13))
Example: