class HListOps[B <: HList] extends ArityIndexOps[B]
Common operations on HList
Author:
Harshad Deo
- B
Type of the HList on which the operations are defined
- Since
0.1
- Grouped
- Alphabetic
- By Inheritance
- HListOps
- ArityIndexOps
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new HListOps(b: B)
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (HListOps[B], B)
-
def
:++:[A, R](a: A)(implicit ev: AppendConstraint[A, B, R]): R
Prepends an hlist to this one
Prepends an hlist to this one
Author:
Harshad Deo
- A
Type of the HList being prepended
- R
Type of the resultant HList
- Since
0.1
-
def
:+:[A](a: A): :+:[A, B]
Adds an element to the head of a HList
Adds an element to the head of a HList
Author:
Harshad Deo
- A
Type of the element being added
- Since
0.1
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
apply[At](i: LiteralHash[Int])(implicit ev: AtConstraint[ValueHash, B, At]): At
Element at the index from left
Element at the index from left
Author:
Harshad Deo
- At
Type of the element at the index position
- Definition Classes
- ArityIndexOps
- Since
0.1
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
count[C](f: (C) ⇒ Boolean)(implicit ev: CountConstraint[B, C]): Int
Count the number of elements of the object for which the predicate holds, provided that each element can be implicitly converted to an object of type C
Count the number of elements of the object for which the predicate holds, provided that each element can be implicitly converted to an object of type C
Author:
Harshad Deo
- C
Type on which the operation is defined
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
down[M[_], R](f: ~>[M, Id])(implicit ev: DownTransformConstraint[B, R, M]): R
Apply a down transformation.
Apply a down transformation. For details, see constraint.DownTransformConstraint
Author:
Harshad Deo
- M
Source context
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
drop[R](i: LiteralHash[Int])(implicit ev: DropConstraint[ValueHash, B, R]): R
Drop the first i elements
Drop the first i elements
Author:
Harshad Deo
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
dropRight[R](i: LiteralHash[Int])(implicit ev: DropRightConstraint[ValueHash, B, R]): R
Drop the last i elements
Drop the last i elements
Author:
Harshad Deo
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
- def ensuring(cond: (HListOps[B]) ⇒ Boolean, msg: ⇒ Any): HListOps[B]
- def ensuring(cond: (HListOps[B]) ⇒ Boolean): HListOps[B]
- def ensuring(cond: Boolean, msg: ⇒ Any): HListOps[B]
- def ensuring(cond: Boolean): HListOps[B]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
exists[C](f: (C) ⇒ Boolean)(implicit ev: ExistsConstraint[B, C]): Boolean
Check if the predicate holds for at least one element of the object, provided that all can be implicitly converted to an object of type C
Check if the predicate holds for at least one element of the object, provided that all can be implicitly converted to an object of type C
Author:
Harshad Deo
- C
Type on which the operation is defined
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
fapply[In, R](in: In)(implicit ev: ApplyConstraint[B, In, R]): R
Apply function to the argument.
Apply function to the argument. If Z is a HList, In is a HList of functions, if it is a tuple, IN is an tuple of the same arity of functions
Author:
Harshad Deo
- In
Type of the input
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
foldLeft[ZT, C](zero: ZT)(f: (ZT, C) ⇒ ZT)(implicit ev: FoldLeftConstraint[B, ZT, C]): ZT
Apply a fold-left like operation on all elements of the object, provided that each element can be implicitly converted to an object of type C
Apply a fold-left like operation on all elements of the object, provided that each element can be implicitly converted to an object of type C
Author:
Harshad Deo
- ZT
Type of the zero (and the resultant object)
- C
Type on which the operation is defined
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
forall[C](f: (C) ⇒ Boolean)(implicit ev: ForallConstraint[B, C]): Boolean
Check if a preficate holds for all elements of the object, provided that all can be implicitly converted to an object of type C
Check if a preficate holds for all elements of the object, provided that all can be implicitly converted to an object of type C
Author:
Harshad Deo
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
foreach[C](f: (C) ⇒ Unit)(implicit ev: ForeachConstraint[B, C]): Unit
Apply a function for each element of the object, provided that all can be implicitly converted to an object of type C
Apply a function for each element of the object, provided that all can be implicitly converted to an object of type C
Author:
Harshad Deo
- C
Type on which the operation is defined
- Definition Classes
- ArityIndexOps
- Since
0.1
- def formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
def
indexFlatMap[At, T, R](i: LiteralHash[Int], f: (At) ⇒ T)(implicit ev: IndexFlatMapConstraint[ValueHash, B, At, T, R]): R
Map the element at index i from the left and then "flatten" the result
Map the element at index i from the left and then "flatten" the result
Author:
Harshad Deo
- At
Type of the old element at the index position
- T
Type of the new element at the index position
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
indexFlatMapRight[At, T, R](i: LiteralHash[Int], f: (At) ⇒ T)(implicit ev: IndexFlatMapRightConstraint[ValueHash, B, At, T, R]): R
Map the element at index i from the right and then "flatten" the result
Map the element at index i from the right and then "flatten" the result
Author:
Harshad Deo
- At
Type of the old element at the index position
- T
Type of the new element at the index position
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
indexMap[At, T, R](i: LiteralHash[Int], f: (At) ⇒ T)(implicit ev: IndexMapConstraint[ValueHash, B, At, T, R]): R
Map the element at index i from the left
Map the element at index i from the left
Author:
Harshad Deo
- At
Type of the old element at the index position
- T
Type of the new element at the index position
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
indexMapRight[At, T, R](i: LiteralHash[Int], f: (At) ⇒ T)(implicit ev: IndexMapRightConstraint[ValueHash, B, At, T, R]): R
Map the element at index i from the right
Map the element at index i from the right
Author:
Harshad Deo
- At
Type of the old element at the index position
- T
Type of the new element at the index position
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
insert[T, R](i: LiteralHash[Int], t: T)(implicit ev: InsertConstraint[ValueHash, B, T, R]): R
Insert an element at index i from the left
Insert an element at index i from the left
Author:
Harshad Deo
- T
Type of the element to be inserted
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
insertM[T, R](i: LiteralHash[Int], tp: T)(implicit ev: InsertMConstraint[ValueHash, B, T, R]): R
Insert element at index i from the left and then "flatten" the result
Insert element at index i from the left and then "flatten" the result
Author:
Harshad Deo
- T
Type of the element to be inserted
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
insertMRight[T, R](i: LiteralHash[Int], tp: T)(implicit ev: InsertMRightConstraint[ValueHash, B, T, R]): R
Insert element at index i from the right and then "flatten" the result
Insert element at index i from the right and then "flatten" the result
Author:
Harshad Deo
- T
Type of the element to be inserted
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
insertRight[T, R](i: LiteralHash[Int], t: T)(implicit ev: InsertRightConstraint[ValueHash, B, T, R]): R
Insert element at index i from the right
Insert element at index i from the right
Author:
Harshad Deo
- T
Type of the element to be inserted
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
length[L <: Dense](implicit ev0: LengthConstraint[B, L], ev1: DenseRep[L]): Long
Length of the collection
Length of the collection
Author:
Harshad Deo
- L
Typelevel marker of length
- Definition Classes
- ArityIndexOps
- Since
0.1
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
def
remove[R](i: LiteralHash[Int])(implicit ev: RemoveConstraint[ValueHash, B, R]): R
Remove element at index i from the left
Remove element at index i from the left
Author:
Harshad Deo
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
removeRight[R](i: LiteralHash[Int])(implicit ev: RemoveRightConstraint[ValueHash, B, R]): R
Remove element at index i from the right
Remove element at index i from the right
Author:
Harshad Deo
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
reverse[R](implicit ev: ReverseConstraint[B, R]): R
Reverses the collection
Reverses the collection
Author:
Harshad Deo
- R
Type of the reverse of the collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
right[At](i: LiteralHash[Int])(implicit ev: AtRightConstraint[ValueHash, B, At]): At
Element at the index from the right
Element at the index from the right
Author:
Harshad Deo
- At
Type of the element at the index position
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
splitAt[L, R](i: LiteralHash[Int])(implicit ev: SplitAtConstraint[ValueHash, B, L, R]): (L, R)
Split at index i from the left
Split at index i from the left
Author:
Harshad Deo
- L
Type of the object to the left of the index position
- R
Type of the object to the right of the index position
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
splitAtRight[L, R](i: LiteralHash[Int])(implicit ev: SplitAtRightConstraint[ValueHash, B, L, R]): (L, R)
Split at index i from the right
Split at index i from the right
Author:
Harshad Deo
- L
Type of the element to the left of the index position
- R
Type of the element to the right of the index position
- Definition Classes
- ArityIndexOps
- Since
0.1
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
t[S]: Tip[S, B]
Builds a type-indexer, can be used to factorize a HList by type.
Builds a type-indexer, can be used to factorize a HList by type. For details, see HList.TIndexer
Author:
Harshad Deo
- S
Type to index against
- Since
0.1
-
def
take[R](i: LiteralHash[Int])(implicit ev: TakeConstraint[ValueHash, B, R]): R
Take the first i elements
Take the first i elements
Author:
Harshad Deo
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
takeRight[R](i: LiteralHash[Int])(implicit ev: TakeRightConstraint[ValueHash, B, R]): R
Take the last i elements
Take the last i elements
Author:
Harshad Deo
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
toList[R](implicit ev: ToListConstraint[B, R]): List[R]
Convert the object to a list, with the element type being the least upper bound of the individual types of the elements
Convert the object to a list, with the element type being the least upper bound of the individual types of the elements
Author:
Harshad Deo
- R
Element type of the resultant list
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
transform[M[_], N[_], R](f: ~>[M, N])(implicit ev: TransformConstraint[B, R, M, N]): R
Apply a natural transformation
Apply a natural transformation
Author:
Harshad Deo
- M
Source context
- N
Destination context
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
unzip[R1, R2](implicit ev: ExternalUnzipConstraint[B, R1, R2]): (R1, R2)
Unzip the elements to form two objects
Unzip the elements to form two objects
Author:
Harshad Deo
- R1
Type of the first collection obtained by unzipping
- R2
Type of the second collection obtained by unzipping
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
updated[A, R](i: LiteralHash[Int], a: A)(implicit ev: UpdatedConstraint[ValueHash, B, A, R]): R
Updated the element at index i from the left
Updated the element at index i from the left
Author:
Harshad Deo
- A
Type of the new element at the index position
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
updatedRight[A, R](i: LiteralHash[Int], a: A)(implicit ev: UpdatedRightConstraint[ValueHash, B, A, R]): R
Update element at index i from the right
Update element at index i from the right
Author:
Harshad Deo
- A
Type of the new element at the index position
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
yapply[F, Out](f: F)(implicit ev: ApplyConstraint[F, B, Out]): Out
Yoda apply, like fapply except with the order of the arguments reversed
Yoda apply, like fapply except with the order of the arguments reversed
Author:
Harshad Deo
- F
Type of the function
- Out
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
-
def
zip[C, R](c: C)(implicit ev: ExternalZipConstraint[B, C, R]): R
Zip with the elements of another object
Zip with the elements of another object
Author:
Harshad Deo
- C
Type of the collection to be zipped with
- R
Type of the resultant collection
- Definition Classes
- ArityIndexOps
- Since
0.1
- def →[B](y: B): (HListOps[B], B)