Ex

trait Ex[+A] extends Flow
Companion
object
trait Flow
trait Lazy
trait Product
trait Equals
class Object
trait Matchable
class Any
class Select[A]
class Count[A]
class DropWhile[A]
class Exists[A]
class Filter[A]
class FilterNot[A]
class Find[A]
class FindLast[A]
class Forall[A]
class IndexWhere[A]
class Select[A]
class SelectFirst[A]
class TakeWhile[A]
class ExSeq[A]
class ExTuple2[T1, T2]
trait WithDefault[A]
class Artifact
class Attr[A]
class BinaryOp[A1, A2, A3, A]
trait CaseDef[A]
class Quote[A]
trait Var[A]
class Const[A]
class Else[A]
class FlatMapExOption[A, B]
class FlatMapExSeq[A, B]
class FlatMapExSeqOption[A, B]
class MapExOption[A, B]
class MapExSeq[A, B]
class Children
class IsEmpty
class NonEmpty
class Size
class It[A]
class Latch[A]
class Attr[A]
trait Make
class OptionGet[A]
class QuaternaryOp[A1, A2, A3, A4, A]
class QuinaryOp[A1, A2, A3, A4, A5, A]
class Coin[A, B]
class Range[A]
class Until[A]
class All
class From
class Until
class Void
class TernaryOp[A1, A2, A3, A]
class TimeStamp
class UnaryOp[A1, A]

Type members

Types

type Repr[T <: Txn[T]] <: IExpr[T, A]

Value members

Concrete methods

def %[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def &(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops

Bit-wise AND

Bit-wise AND

def &&(that: Ex[A])(implicit num: NumBool[A]): Ex[A]
Implicitly added by ops

Logical AND

Logical AND

def *[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def +[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def ++[B >: A](that: Ex[Seq[B]]): Ex[Seq[B]]
Implicitly added by seqOps

A concatenation of this sequence with that sequence

A concatenation of this sequence with that sequence

def ++(that: Ex[String]): Ex[String]
Implicitly added by stringOps
def +:[B >: A](elem: Ex[B]): Ex[Seq[B]]
Implicitly added by seqOps

A new sequence with the element prepended

A new sequence with the element prepended

def -[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def -->(that: Sink[A]): Unit
Implicitly added by ops
def /[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDiv[A2]): Ex[A2]
Implicitly added by ops
def :+[B >: A](elem: Ex[B]): Ex[Seq[B]]
Implicitly added by seqOps

A new sequence with the element appended

A new sequence with the element appended

def <(that: Ex[A])(implicit ord: Ord[A]): Ex[Boolean]
Implicitly added by ops
def <<(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops
def <=(that: Ex[A])(implicit ord: Ord[A]): Ex[Boolean]
Implicitly added by ops
def <|(tr: Trig): Ex[A]
Implicitly added by ops

Alias for latch

Alias for latch

def >(that: Ex[A])(implicit ord: Ord[A]): Ex[Boolean]
Implicitly added by ops
def >=(that: Ex[A])(implicit ord: Ord[A]): Ex[Boolean]
Implicitly added by ops
def >>(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops
def >>>(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops
def ^(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops

Bit-wise XOR

Bit-wise XOR

def ^^(that: Ex[A])(implicit num: NumBool[A]): Ex[A]
Implicitly added by ops

Logical XOR

Logical XOR

def _1: Ex[A]
Implicitly added by tuple2Ops
def _2: Ex[B]
Implicitly added by tuple2Ops
def abs(implicit num: Num[A]): Ex[A]
Implicitly added by ops
def absDif[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def acos[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def ampDb[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def appended[B >: A](elem: Ex[B]): Ex[Seq[B]]
Implicitly added by seqOps

A new sequence with the element appended

A new sequence with the element appended

def apply(index: Ex[Int])(implicit d: HasDefault[A]): Ex[A]
Implicitly added by seqOps

The element at a given index if the index is valid, otherwise the default value

The element at a given index if the index is valid, otherwise the default value

def applyOption(index: Ex[Int]): Ex[Option[A]]
Implicitly added by seqOps

The element at a given index if the index is valid

The element at a given index if the index is valid

def asObj(implicit cm: CanMake[A]): Make
Implicitly added by ops

Views this expression as a (yet to make) Obj. In order to actually create the object, .make has to be called on it.

Views this expression as a (yet to make) Obj. In order to actually create the object, .make has to be called on it.

def asin[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def atan[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def atan2[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDouble[A2]): Ex[A2]
Implicitly added by ops
def ceil(implicit num: NumFrac[A]): Ex[A]
Implicitly added by ops
Implicitly added by ops
def clip[A1, A2](lo: Ex[A1], hi: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def clip(pos: Ex[Long]): Ex[Long]
Implicitly added by spanOps
def clip2[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def closedOption: Ex[Option[Span]]
Implicitly added by spanOps
def concat[B >: A](that: Ex[Seq[B]]): Ex[Seq[B]]
Implicitly added by seqOps

A concatenation of this sequence with that sequence

A concatenation of this sequence with that sequence

def contains[B >: A](elem: Ex[B]): Ex[Boolean]
Implicitly added by optionOps
def contains(elem: Ex[A]): Ex[Boolean]
Implicitly added by seqOps

Whether this collection contains an element or not

Whether this collection contains an element or not

def contains(pos: Ex[Long]): Ex[Boolean]
Implicitly added by spanOps
def contains(that: Ex[String]): Ex[Boolean]
Implicitly added by stringOps
def cos[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def cosh[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def count(p: Ex[A] => Ex[Boolean]): Ex[Int]
Implicitly added by seqOps
def cpsMidi[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def cpsOct[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def cubed(implicit num: Num[A]): Ex[A]
Implicitly added by ops
def dbAmp[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def difSqr[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def diff(that: Ex[Seq[A]]): Ex[Seq[A]]
Implicitly added by seqOps

The multiset difference between this sequence and that sequence

The multiset difference between this sequence and that sequence

def differentiate(implicit num: Num[A]): Ex[Seq[A]]
Implicitly added by seqOps
def distinct: Ex[Seq[A]]
Implicitly added by seqOps

All the elements of this sequence ignoring the duplicates

All the elements of this sequence ignoring the duplicates

def drop(n: Ex[Int]): Ex[Seq[A]]
Implicitly added by seqOps

All elements except first n ones

All elements except first n ones

def drop(n: Ex[Int]): Ex[String]
Implicitly added by stringOps
def dropRight(n: Ex[Int]): Ex[Seq[A]]
Implicitly added by seqOps

The rest of this sequence without its n last elements

The rest of this sequence without its n last elements

def dropWhile(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
Implicitly added by seqOps
def endsWith(that: Ex[Seq[A]]): Ex[Boolean]
Implicitly added by seqOps

Tests whether this sequence ends with that sequence

Tests whether this sequence ends with that sequence

def endsWith(that: Ex[String]): Ex[Boolean]
Implicitly added by stringOps
def excess[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def exists(p: Ex[A] => Ex[Boolean]): Ex[Boolean]
Implicitly added by seqOps
def exp[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def expExp[A1, A2](inLo: Ex[A], inHi: Ex[A], outLo: Ex[A1], outHi: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDouble[A2]): Ex[A2]
Implicitly added by ops
def expLin[A1, A2](inLo: Ex[A], inHi: Ex[A], outLo: Ex[A1], outHi: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDouble[A2]): Ex[A2]
Implicitly added by ops
def filter(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
Implicitly added by seqOps
def filterNot(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
Implicitly added by seqOps
def find(p: Ex[A] => Ex[Boolean]): Ex[Option[A]]
Implicitly added by seqOps
def findLast(p: Ex[A] => Ex[Boolean]): Ex[Option[A]]
Implicitly added by seqOps
def flatMap[B, To](f: Ex[A] => B)(implicit fm: CanFlatMap[Option, B, To]): To
Implicitly added by optionOps
def flatMap[B, To](f: Ex[A] => B)(implicit fm: CanFlatMap[Seq, B, To]): To
Implicitly added by seqOps
def floor(implicit num: NumFrac[A]): Ex[A]
Implicitly added by ops
def fold[A1, A2](lo: Ex[A1], hi: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def fold2[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def forall(p: Ex[A] => Ex[Boolean]): Ex[Boolean]
Implicitly added by seqOps
def format(args: Ex[Any]*): Ex[String]
Implicitly added by stringOps

Applies 'printf' style formatting. See StringFormat for details.

Applies 'printf' style formatting. See StringFormat for details.

def frac(implicit num: NumFrac[A]): Ex[A]
Implicitly added by ops
def gcd(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops
def get(implicit d: HasDefault[A]): Ex[A]
Implicitly added by optionOps
def getOrElse[B >: A](default: Ex[B]): Ex[B]
Implicitly added by optionOps
def grouped(size: Ex[Int]): Ex[Seq[Seq[A]]]
Implicitly added by seqOps

Partitions elements in fixed size sequences

Partitions elements in fixed size sequences

def head(implicit d: HasDefault[A]): Ex[A]
Implicitly added by seqOps

The first element if the sequence is non-empty, otherwise the default value

The first element if the sequence is non-empty, otherwise the default value

def headOption: Ex[Option[A]]
Implicitly added by seqOps

The first element if the sequence is non-empty

The first element if the sequence is non-empty

def hypot[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDouble[A2]): Ex[A2]
Implicitly added by ops
def hypotApx[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDouble[A2]): Ex[A2]
Implicitly added by ops
def indexOf(elem: Ex[A]): Ex[Int]
Implicitly added by seqOps

The index of the first occurrence of elem in this sequence, or -1 if not found

The index of the first occurrence of elem in this sequence, or -1 if not found

def indexOf(elem: Ex[A], from: Ex[Int]): Ex[Int]
Implicitly added by seqOps

The index of the first occurrence of elem at or after from in this sequence, or -1 if not found

The index of the first occurrence of elem at or after from in this sequence, or -1 if not found

def indexOf(that: Ex[String]): Ex[Int]
Implicitly added by stringOps
def indexOfSlice(that: Ex[Seq[A]]): Ex[Int]
Implicitly added by seqOps

First index where this sequence contains that sequence as a slice, or -1 if not found

First index where this sequence contains that sequence as a slice, or -1 if not found

def indexOfSlice(that: Ex[Seq[A]], from: Ex[Int]): Ex[Int]
Implicitly added by seqOps

First index at or after from where this sequence contains that sequence as a slice, or -1 if not found

First index at or after from where this sequence contains that sequence as a slice, or -1 if not found

def indexWhere(p: Ex[A] => Ex[Boolean]): Ex[Int]
Implicitly added by seqOps
def indices: Ex[Seq[Int]]
Implicitly added by seqOps

Indices from zero until the size of this sequence

Indices from zero until the size of this sequence

def integrate(implicit num: Num[A]): Ex[Seq[A]]
Implicitly added by seqOps
def intersect(that: Ex[Seq[A]]): Ex[Seq[A]]
Implicitly added by seqOps

The multiset intersection between this sequence and that sequence

The multiset intersection between this sequence and that sequence

def intersect(that: Ex[SpanLike]): Ex[SpanLike]
Implicitly added by spanOps
def isDefined: Ex[Boolean]
Implicitly added by optionOps
def isDefinedAt(index: Ex[Int]): Ex[Boolean]
Implicitly added by seqOps

Whether an index lies within this sequence

Whether an index lies within this sequence

def isEmpty: Ex[Boolean]
Implicitly added by optionOps
def isEmpty: Ex[Boolean]
Implicitly added by seqOps
def isEmpty: Ex[Boolean]
Implicitly added by spanOps
def isEmpty: Ex[Boolean]
Implicitly added by stringOps
def last(implicit d: HasDefault[A]): Ex[A]
Implicitly added by seqOps

The last element if the sequence is non-empty, otherwise the default value

The last element if the sequence is non-empty, otherwise the default value

def lastIndexOf(elem: Ex[A]): Ex[Int]
Implicitly added by seqOps

The index of the last occurrence of elem in this sequence, or -1 if not found

The index of the last occurrence of elem in this sequence, or -1 if not found

def lastIndexOf(elem: Ex[A], end: Ex[Int]): Ex[Int]
Implicitly added by seqOps

The index of the last occurrence of elem at or before end in this sequence, or -1 if not found

The index of the last occurrence of elem at or before end in this sequence, or -1 if not found

def lastIndexOf(that: Ex[String]): Ex[Int]
Implicitly added by stringOps
def lastIndexOfSlice(that: Ex[Seq[A]]): Ex[Int]
Implicitly added by seqOps

Last index where this sequence contains that sequence as a slice, or -1 if not found

Last index where this sequence contains that sequence as a slice, or -1 if not found

def lastIndexOfSlice(that: Ex[Seq[A]], end: Ex[Int]): Ex[Int]
Implicitly added by seqOps

Last index at or before end where this sequence contains that sequence as a slice, or -1 if not found

Last index at or before end where this sequence contains that sequence as a slice, or -1 if not found

def lastOption: Ex[Option[A]]
Implicitly added by seqOps

The last element if the sequence is non-empty

The last element if the sequence is non-empty

def latch(tr: Trig): Ex[A]
Implicitly added by ops

Latches the expression based on the trigger argument. The initial state of the returned expression corresponds to the initial state of the input expression. Subsequent values are updated and cached only when a trigger occurs.

Latches the expression based on the trigger argument. The initial state of the returned expression corresponds to the initial state of the input expression. Subsequent values are updated and cached only when a trigger occurs.

def lcm(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops
def length(implicit ev: Ex[A] =:= Ex[Span]): Ex[Long]
Implicitly added by spanOps
def length: Ex[Int]
Implicitly added by stringOps
def lengthOption: Ex[Option[Long]]
Implicitly added by spanOps
def linExp[A1, A2](inLo: Ex[A], inHi: Ex[A], outLo: Ex[A1], outHi: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDouble[A2]): Ex[A2]
Implicitly added by ops
def linLin[A1, A2](inLo: Ex[A], inHi: Ex[A], outLo: Ex[A1], outHi: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumFrac[A2]): Ex[A2]
Implicitly added by ops
def log[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def log10[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def log2[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def map[B, To](f: Ex[A] => B)(implicit m: CanMap[Option, B, To]): To
Implicitly added by optionOps
def map[B, To](f: Ex[A] => B)(implicit m: CanMap[Seq, B, To]): To
Implicitly added by seqOps
def max[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def maxOption(implicit ord: ScalarOrd[A]): Ex[Option[A]]
Implicitly added by seqOps
def midiCps[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def midiRatio[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def min[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def minOption(implicit ord: ScalarOrd[A]): Ex[Option[A]]
Implicitly added by seqOps
def mkString: Ex[String]
Implicitly added by seqOps
def mkString(sep: Ex[String]): Ex[String]
Implicitly added by seqOps
def mkString(start: Ex[String], sep: Ex[String], end: Ex[String]): Ex[String]
Implicitly added by seqOps
def mod[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def nonEmpty: Ex[Boolean]
Implicitly added by optionOps
def nonEmpty: Ex[Boolean]
Implicitly added by seqOps
def nonEmpty: Ex[Boolean]
Implicitly added by spanOps
def nonEmpty: Ex[Boolean]
Implicitly added by stringOps
def octCps[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def orElse[B >: A](alternative: Ex[Option[B]]): Ex[Option[B]]
Implicitly added by optionOps
def overlaps(that: Ex[SpanLike]): Ex[Boolean]
Implicitly added by spanOps
def padTo[B >: A](len: Ex[Int], elem: Ex[B]): Ex[Seq[B]]
Implicitly added by seqOps
def patch[B >: A](from: Ex[Int], other: Ex[Seq[B]], replaced: Ex[Int]): Ex[Seq[B]]
Implicitly added by seqOps
def permutations: Ex[Seq[Seq[A]]]
Implicitly added by seqOps
def pow[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: NumDouble[A2]): Ex[A2]
Implicitly added by ops
def prepended[B >: A](elem: Ex[B]): Ex[Seq[B]]
Implicitly added by seqOps
def product(implicit num: Num[A]): Ex[A]
Implicitly added by seqOps
def ratioMidi[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def reciprocal[B](implicit w: Widen[A, B], num: NumFrac[B]): Ex[B]
Implicitly added by ops
def reverse: Ex[Seq[A]]
Implicitly added by seqOps
def roundTo[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def roundUpTo[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def sameElements[B >: A](that: Ex[Seq[B]]): Ex[Boolean]
Implicitly added by seqOps
def select[B](implicit bridge: Bridge[B], ev: Ex[Option[A]] =:= Ex[Option[Obj]]): Ex[Option[B]]
Implicitly added by optionOps
def select[B](implicit bridge: Bridge[B], ev: Ex[Seq[A]] =:= Ex[Seq[Obj]]): Ex[Seq[B]]
Implicitly added by seqOps
def selectFirst[B](implicit bridge: Bridge[B], ev: Ex[Seq[A]] =:= Ex[Seq[Obj]]): Ex[Option[B]]
Implicitly added by seqOps
def shift(delta: Ex[Long]): Ex[SpanLike]
Implicitly added by spanOps
def sig_!=(that: Ex[A])(implicit eq: Eq[A]): Ex[Boolean]
Implicitly added by ops
def sig_==(that: Ex[A])(implicit eq: Eq[A]): Ex[Boolean]
Implicitly added by ops
def signum(implicit num: Num[A]): Ex[A]
Implicitly added by ops
def sin[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def sinh[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def size: Ex[Int]
Implicitly added by seqOps

The number of elements in the sequence

The number of elements in the sequence

def size: Ex[Int]
Implicitly added by stringOps
def slice(from: Ex[Int], until: Ex[Int]): Ex[Seq[A]]
Implicitly added by seqOps
def slice(from: Ex[Int], until: Ex[Int]): Ex[String]
Implicitly added by stringOps
def sliding(size: Ex[Int], step: Ex[Int]): Ex[Seq[Seq[A]]]
Implicitly added by seqOps

Groups elements in fixed size blocks by passing a "sliding window" over them. Note that both size and step are automatically constraint to values of one and greater.

Groups elements in fixed size blocks by passing a "sliding window" over them. Note that both size and step are automatically constraint to values of one and greater.

def sorted(implicit ord: ScalarOrd[A]): Ex[Seq[A]]
Implicitly added by seqOps
def split(regex: Ex[String], limit: Ex[Int]): Ex[Seq[String]]
Implicitly added by stringOps
def splitAt(n: Ex[Int]): Ex[(Seq[A], Seq[A])]
Implicitly added by seqOps
def sqrDif[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def sqrSum[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def sqrt[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def squared(implicit num: Num[A]): Ex[A]
Implicitly added by ops
def start(implicit ev: Ex[A] =:= Ex[Span]): Ex[Long]
Implicitly added by spanOps
def startOption: Ex[Option[Long]]
Implicitly added by spanOps
def startsWith(that: Ex[Seq[A]], offset: Ex[Int]): Ex[Boolean]
Implicitly added by seqOps

Tests whether this sequence starts with that sequence

Tests whether this sequence starts with that sequence

def startsWith(that: Ex[String]): Ex[Boolean]
Implicitly added by stringOps
def stop(implicit ev: Ex[A] =:= Ex[Span]): Ex[Long]
Implicitly added by spanOps
def stopOption: Ex[Option[Long]]
Implicitly added by spanOps
def sum(implicit num: Num[A]): Ex[A]
Implicitly added by seqOps
def sumSqr[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def swap: Ex[(B, A)]
Implicitly added by tuple2Ops
def take(n: Ex[Int]): Ex[Seq[A]]
Implicitly added by seqOps
def take(n: Ex[Int]): Ex[String]
Implicitly added by stringOps
def takeRight(n: Ex[Int]): Ex[Seq[A]]
Implicitly added by seqOps
def takeWhile(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
Implicitly added by seqOps
def tan[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def tanh[B](implicit wd: WidenToDouble[A, B]): Ex[B]
Implicitly added by ops
def toBooleanOption: Ex[Option[Boolean]]
Implicitly added by stringOps
def toDouble(implicit to: ToNum[A]): Ex[Double]
Implicitly added by ops
def toDoubleOption: Ex[Option[Double]]
Implicitly added by stringOps
def toInt(implicit to: ToNum[A]): Ex[Int]
Implicitly added by ops
def toIntOption: Ex[Option[Int]]
Implicitly added by stringOps
def toList: Ex[List[A]]
Implicitly added by optionOps
def toLong(implicit to: ToNum[A]): Ex[Long]
Implicitly added by ops
def toStr: Ex[String]
Implicitly added by ops
Implicitly added by booleanOps
def touches(that: Ex[SpanLike]): Ex[Boolean]
Implicitly added by spanOps
def trunc[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def unary_!(implicit num: NumBool[A]): Ex[A]
Implicitly added by ops
def unary_-(implicit num: Num[A]): Ex[A]
Implicitly added by ops
def unary_~(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops
def union(that: Ex[SpanLike]): Ex[SpanLike]
Implicitly added by spanOps
def updated[B >: A](index: Ex[Int], elem: Ex[B]): Ex[Seq[B]]
Implicitly added by seqOps

A new sequence equal to this sequence with one single replaced elem at index. If the index lies outside the sequence, the original sequence is returned.

A new sequence equal to this sequence with one single replaced elem at index. If the index lies outside the sequence, the original sequence is returned.

def withFilter(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
Implicitly added by seqOps
def wrap[A1, A2](lo: Ex[A1], hi: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def wrap2[A1, A2](that: Ex[A1])(implicit w: Widen2[A, A1, A2], num: Num[A2]): Ex[A2]
Implicitly added by ops
def zip[B](that: Ex[Seq[B]]): Ex[Seq[(A, B)]]
Implicitly added by seqOps
def zipWithIndex: Ex[Seq[(A, Int)]]
Implicitly added by seqOps
def |(that: Ex[A])(implicit num: NumInt[A]): Ex[A]
Implicitly added by ops

Bit-wise OR

Bit-wise OR

def ||(that: Ex[A])(implicit num: NumBool[A]): Ex[A]
Implicitly added by ops

Logical OR

Logical OR

Deprecated methods

@deprecated("Use --> instead", since = "4.4.5")
def --->(that: Sink[A]): Unit
Implicitly added by ops
Deprecated
[Since version 4.4.5]

Inherited methods

def canEqual(that: Any): Boolean
Inherited from
Equals
final
def expand[T <: Txn[LazyRef(...)]](implicit ctx: Context[T], tx: T): Repr[T]
Inherited from
Lazy
protected
def mkRepr[T <: Txn[LazyRef(...)]](implicit ctx: Context[T], tx: T): Repr[T]
Inherited from
Lazy
def productArity: Int
Inherited from
Product
def productElement(n: Int): Any
Inherited from
Product
def productElementName(n: Int): String
Inherited from
Product
def productElementNames: Iterator[String]
Inherited from
Product
def productIterator: Iterator[Any]
Inherited from
Product
def productPrefix: String
Inherited from
Product

Inherited fields

@transient
final protected
val ref: Object
Inherited from
Lazy