function

object At extends AtFunctions with Serializable

object Cons extends ConsFunctions with Serializable

object Cons1 extends HConsFunctions with Serializable

object Curry extends CurryFunctions with Serializable

object Each extends EachFunctions with Serializable

object Empty extends EmptyFunctions with Serializable

object Field1 extends Field1Functions with Serializable

object Field2 extends Field2Functions with Serializable

object Field3 extends Field3Functions with Serializable

object Field4 extends Field4Functions with Serializable

object Field5 extends Field5Functions with Serializable

object Field6 extends Field6Functions with Serializable

object Fields extends Field1Functions with Field2Functions with Field3Functions with Field4Functions with Field5Functions with Field6Functions

object FilterIndex extends FilterIndexFunctions with Serializable

object Index extends IndexFunctions with Serializable

object Reverse extends ReverseFunctions with Serializable

object Snoc extends SnocFunctions with Serializable

object Snoc1 extends Snoc1Functions with Serializable

final def _cons[S, A](head: A, tail: S)(implicit ev: Cons[S, A]): S

append an element to the head

final def _cons1[S, H, T](head: H, tail: T)(implicit ev: Cons1[S, H, T]): S

append an element to the head

def _empty[S](implicit ev: Empty[S]): S

def _isEmpty[S](s: S)(implicit ev: Empty[S]): Boolean

def _reverse[S](s: S)(implicit ev: Reverse[S, S]): S

final def _snoc[S, A](init: S, last: A)(implicit ev: Snoc[S, A]): S

append an element to the end

final def _snoc1[S, I, L](init: I, last: L)(implicit ev: Snoc1[S, I, L]): S

append an element to the end

final def _uncons[S, A](s: S)(implicit ev: Cons[S, A]): Option[(A, S)]

deconstruct an S between its head and tail

final def _uncons1[S, H, T](s: S)(implicit ev: Cons1[S, H, T]): (H, T)

deconstruct an S between its head and tail

final def _unsnoc[S, A](s: S)(implicit ev: Snoc[S, A]): Option[(S, A)]

deconstruct an S between its init and last

final def _unsnoc1[S, I, L](s: S)(implicit ev: Snoc1[S, I, L]): (I, L)

deconstruct an S between its init and last

def at[S, I, A](i: I)(implicit ev: At[S, I, A]): Lens[S, Option[A]]

def atIndex[S, I, A](implicit ev: At[S, I, A]): Index[S, I, A]

final def cons[S, A](implicit ev: Cons[S, A]): Prism[S, (A, S)]

final def cons1[S, H, T](implicit ev: Cons1[S, H, T]): Iso[S, (H, T)]

def curry[F, G](implicit ev: Curry[F, G]): Iso[F, G]

def each[S, A](implicit ev: Each[S, A]): Traversal[S, A]

def empty[S](implicit ev: Empty[S]): Prism[S, Unit]

def fifth[S, A](implicit ev: Field5[S, A]): Lens[S, A]

def filterIndex[S, I, A](predicate: (I) ⇒ Boolean)(implicit ev: FilterIndex[S, I, A]): Traversal[S, A]

def first[S, A](implicit ev: Field1[S, A]): Lens[S, A]

def fourth[S, A](implicit ev: Field4[S, A]): Lens[S, A]

final def head[S, H, T](implicit ev: Cons1[S, H, T]): Lens[S, H]

final def headOption[S, A](implicit ev: Cons[S, A]): Optional[S, A]

def index[S, I, A](i: I)(implicit ev: Index[S, I, A]): Optional[S, A]

final def init[S, I, L](implicit ev: Snoc1[S, I, L]): Lens[S, I]

final def initOption[S, A](implicit ev: Snoc[S, A]): Optional[S, S]

final def last[S, I, L](implicit ev: Snoc1[S, I, L]): Lens[S, L]

final def lastOption[S, A](implicit ev: Snoc[S, A]): Optional[S, A]

def reverse[S, A](implicit ev: Reverse[S, A]): Iso[S, A]

def reverseFromReverseFunction[S](_reverse: (S) ⇒ S): Reverse[S, S]

def second[S, A](implicit ev: Field2[S, A]): Lens[S, A]

def sixth[S, A](implicit ev: Field6[S, A]): Lens[S, A]

final def snoc[S, A](implicit ev: Snoc[S, A]): Prism[S, (S, A)]

final def snoc1[S, I, L](implicit ev: Snoc1[S, I, L]): Iso[S, (I, L)]

final def tail[S, H, T](implicit ev: Cons1[S, H, T]): Lens[S, T]

final def tailOption[S, A](implicit ev: Cons[S, A]): Optional[S, S]

def third[S, A](implicit ev: Field3[S, A]): Lens[S, A]

def traverseEach[S[_], A](implicit arg0: Traverse[S]): Each[S[A], A]

def traverseFilterIndex[S[_], A](zipWithIndex: (S[A]) ⇒ S[(A, Int)])(implicit arg0: Traverse[S]): FilterIndex[S[A], Int, A]

def uncurry[F, G](implicit ev: Curry[F, G]): Iso[G, F]

final def headMaybe[S, A](implicit ev: Cons[S, A]): Optional[S, A]

final def initMaybe[S, A](implicit ev: Snoc[S, A]): Optional[S, S]

final def lastMaybe[S, A](implicit ev: Snoc[S, A]): Optional[S, A]

final def tailMaybe[S, A](implicit ev: Cons[S, A]): Optional[S, S]