Std.NonEmpty

29 public declarations

• all&Std.NonEmpty.NonEmpty[T] -> fn(T) -> Bool -> Bool

  Whether every element satisfies a test.

  fn
• any&Std.NonEmpty.NonEmpty[T] -> fn(T) -> Bool -> Bool

  Whether any element satisfies a test.

  fn
• append&Std.NonEmpty.NonEmpty[T] -> T -> Std.NonEmpty.NonEmpty[T]

  An element added to the end.

  fn
• concat&Std.NonEmpty.NonEmpty[T] -> &Std.NonEmpty.NonEmpty[T] -> Std.NonEmpty.NonEmpty[T]

  Two sequences joined.

  fn
• contains&Std.NonEmpty.NonEmpty[T] -> T -> Bool where T: Eq

  Whether an element is present.

  fn
• filter&Std.NonEmpty.NonEmpty[T] -> fn(T) -> Bool -> Array[T]

  The elements that satisfy a test, as an ordinary array — filtering can

  fn
• find&Std.NonEmpty.NonEmpty[T] -> fn(T) -> Bool -> Option[T]

  The first element satisfying a test, or `None`.

  fn
• first&Std.NonEmpty.NonEmpty[T] -> T

  The first element. There is always one.

  fn
• fold&Std.NonEmpty.NonEmpty[T] -> A -> fn(A, T) -> A -> A

  The elements combined from the left, starting from a value of your own.

  fn
• fromArray&Array[T] -> Option[Std.NonEmpty.NonEmpty[T]]

  An array as a non-empty sequence, or `None` when it is empty.

  fn
• group&Array[T] -> Array[Std.NonEmpty.NonEmpty[T]] where T: Eq

  Adjacent equal elements gathered.

  fn
• groupBy&Array[T] -> fn(T, T) -> Bool -> Array[Std.NonEmpty.NonEmpty[T]]

  Adjacent equal elements gathered, each group non-empty by construction.

  fn
• last&Std.NonEmpty.NonEmpty[T] -> T

  The last element. There is always one.

  fn
• length&Std.NonEmpty.NonEmpty[T] -> Int

  How many elements there are, which is never fewer than one.

  fn
• makeT -> Array[T] -> Std.NonEmpty.NonEmpty[T]

  A head and the rest.

  fn
• map&Std.NonEmpty.NonEmpty[A] -> fn(A) -> B -> Std.NonEmpty.NonEmpty[B]

  Every element transformed. A sequence that had one still has one.

  fn
• maximum&Std.NonEmpty.NonEmpty[T] -> T where T: Ord

  The largest element. There is always one.

  fn
• maximumBy&Std.NonEmpty.NonEmpty[T] -> fn(T, T) -> Bool -> T

  The largest element under an ordering. There is always one.

  fn
• minimum&Std.NonEmpty.NonEmpty[T] -> T where T: Ord

  The smallest element. There is always one, so this answers a value rather

  fn
• minimumBy&Std.NonEmpty.NonEmpty[T] -> fn(T, T) -> Bool -> T

  The smallest element under an ordering. There is always one.

  fn
• NonEmpty

  A sequence that has at least one element, and says so in its type.

  type
• oneT -> Std.NonEmpty.NonEmpty[T]

  A sequence of one.

  fn
• prepend&Std.NonEmpty.NonEmpty[T] -> T -> Std.NonEmpty.NonEmpty[T]

  An element added to the front.

  fn
• reduce&Std.NonEmpty.NonEmpty[T] -> fn(T, T) -> T -> T

  The elements combined from the left, starting from the first one.

  fn
• rest&Std.NonEmpty.NonEmpty[T] -> Array[T]

  Everything after the first element, which may be empty.

  fn
• reversed&Std.NonEmpty.NonEmpty[T] -> Std.NonEmpty.NonEmpty[T]

  The elements in the opposite order.

  fn
• sortBy&Std.NonEmpty.NonEmpty[T] -> fn(T, T) -> Bool -> Std.NonEmpty.NonEmpty[T]

  The elements in order under an ordering of your own.

  fn
• sorted&Std.NonEmpty.NonEmpty[T] -> Std.NonEmpty.NonEmpty[T] where T: Ord

  The elements in order.

  fn
• toArray&Std.NonEmpty.NonEmpty[T] -> Array[T]

  Every element, as an ordinary array.

  fn