object
ListLemmas
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
def
acc_drop[A](l: List[A], n: BigInt, i: BigInt): Boolean
-
def
acc_slice[A](l: List[A], from: BigInt, until: BigInt, i: BigInt): Boolean
-
def
acc_take[A](l: List[A], n: BigInt, i: BigInt): Boolean
-
def
acc_updated_eq[A](l: List[A], i: BigInt, x: A, j: BigInt): Boolean
-
def
acc_updated_neq[A](l: List[A], i: BigInt, x: A, j: BigInt): Boolean
-
def
appendAssoc[T](l1: List[T], l2: List[T], l3: List[T]): Boolean
-
def
appendContent[A](l1: List[A], l2: List[A]): Boolean
-
def
appendIndex[T](l1: List[T], l2: List[T], i: BigInt): Boolean
-
def
appendInsert[T](l1: List[T], l2: List[T], i: BigInt, y: T): Boolean
-
def
appendTakeDrop[T](l1: List[T], l2: List[T], n: BigInt): Boolean
-
def
appendUpdate[T](l1: List[T], l2: List[T], i: BigInt, y: T): Boolean
-
def
append_forall[A](l1: List[A], l2: List[A], p: (A) ⇒ Boolean): Boolean
-
def
append_forall[A](l: List[A], e: A, p: (A) ⇒ Boolean): Boolean
-
def
apply_forall[A](l: List[A], p: (A) ⇒ Boolean, e: A): Boolean
-
final
def
asInstanceOf[T0]: T0
-
def
associative[T, U](l1: List[T], l2: List[T], f: (List[T]) ⇒ U, op: (U, U) ⇒ U): Boolean
-
def
clone(): AnyRef
-
def
concat_contains[T](l1: List[T], l2: List[T], e: T): Boolean
-
def
consIsAppend[T](l: List[T], t: T): Boolean
-
def
contains_count[A](l: List[A], e: A): Boolean
-
def
countAssoc[T](l1: List[T], l2: List[T], p: (T) ⇒ Boolean): Boolean
-
def
count_contains[A](l: List[A], e: A): Boolean
-
def
cut_as_take_drop[A](l: List[A], n: BigInt): Boolean
-
def
distinct_count[A](l: List[A]): Boolean
-
def
drop_forall[A](l: List[A], n: BigInt, p: (A) ⇒ Boolean): Boolean
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
existsAssoc[T](l1: List[T], l2: List[T], p: (T) ⇒ Boolean): Boolean
-
def
exists_forall[T](l: List[T], p: (T) ⇒ Boolean): Boolean
-
def
finalize(): Unit
-
def
flattenPreservesContent[T](ls: List[List[T]]): Boolean
-
def
folds[A, B](xs: List[A], z: B, f: (B, A) ⇒ B): Boolean
-
def
forallAssoc[T](l1: List[T], l2: List[T], p: (T) ⇒ Boolean): Boolean
-
def
forall_exists[T](l: List[T], p: (T) ⇒ Boolean): Boolean
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
def
headReverseLast[T](l: List[T]): Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
leftUnitAppend[T](l1: List[T]): Boolean
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
prefix_tran[A](l1: List[A], l2: List[A], l3: List[A]): Boolean
-
def
reverseAppend[T](l1: List[T], l2: List[T]): Boolean
-
def
reverseIndex[T](l: List[T], i: BigInt): Boolean
-
def
reverseReverse[T](l: List[T]): Boolean
-
def
reverse_prefix[A](l1: List[A], l2: List[A]): Boolean
-
def
rightUnitAppend[T](l1: List[T]): Boolean
-
def
scanVsFoldLeft[A, B](l: List[A], z: B, f: (B, A) ⇒ B): Boolean
-
def
scanVsFoldRight[A, B](l: List[A], z: B, f: (A, B) ⇒ B): Boolean
-
def
slice_all[A](l: List[A]): Boolean
-
def
snocAfterAppend[T](l1: List[T], l2: List[T], t: T): Boolean
-
def
snocFoldRight[A, B](xs: List[A], y: A, z: B, f: (A, B) ⇒ B): Boolean
-
def
snocIndex[T](l: List[T], t: T, i: BigInt): Boolean
-
def
snocIsAppend[T](l: List[T], t: T): Boolean
-
def
snocLast[T](l: List[T], x: T): Boolean
-
def
snocReverse[T](l: List[T], t: T): Boolean
-
def
suffix_tran[A](l1: List[A], l2: List[A], l3: List[A]): Boolean
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
take_all[A](l: List[A], n: BigInt): Boolean
-
def
toString(): String
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
Inherited from AnyRef
Inherited from Any
