kty/nz.adjmunro.kty.tuple.numbery/Numbery4D

Numbery4D

interface Numbery4D<ActualWrapper : Numbery4D<ActualWrapper, BackingField>, BackingField : Numbery<BackingField, *>> : Mathable<ActualWrapper, Tuple4<BackingField>> , NumberMathable<ActualWrapper, Tuple4<BackingField>> , Tuple.Tuple4d<BackingField, BackingField, BackingField, BackingField>

Properties

addByNumber

open override val addByNumber: MergeABtoA<Tuple4<BackingField>, Number>

divide

open override val divide: Merge<Tuple4<BackingField>>

divideByNumber

open override val divideByNumber: MergeABtoA<Tuple4<BackingField>, Number>

minus

open override val minus: Merge<Tuple4<BackingField>>

multiplyByNumber

open override val multiplyByNumber: MergeABtoA<Tuple4<BackingField>, Number>

plus

open override val plus: Merge<Tuple4<BackingField>>

reconstruct

open override val reconstruct: (Tuple4<BackingField>) -> ActualWrapper

Function reference to the constructor of the value class.

reconstructor

abstract val reconstructor: (BackingField, BackingField, BackingField, BackingField) -> ActualWrapper

remainder

open override val remainder: Merge<Tuple4<BackingField>>

remainderByNumber

open override val remainderByNumber: MergeABtoA<Tuple4<BackingField>, Number>

size

open override val size: Int

subtractByNumber

open override val subtractByNumber: MergeABtoA<Tuple4<BackingField>, Number>

times

open override val times: Merge<Tuple4<BackingField>>

value

open override val value: Tuple4<BackingField>

The backing field that is wrapped in the value class.

Functions

component1

abstract operator fun component1(): BackingField

component2

abstract operator fun component2(): BackingField

component3

abstract operator fun component3(): BackingField

component4

abstract operator fun component4(): BackingField

div

open operator fun div(other: ActualWrapper): ActualWrapper

open operator fun div(num: Number): ActualWrapper

merge

open fun merge(other: ActualWrapper, transform: Merge<Tuple4<BackingField>>): ActualWrapper

Merges this Boxed instance with another Boxed instance to create a new instance of the same type.

open fun merge(other: Number, transform: MergeABtoA<Tuple4<BackingField>, Number>): ActualWrapper

minus

open operator fun minus(num: Number): ActualWrapper

open operator fun minus(other: ActualWrapper): ActualWrapper

plus

open operator fun plus(other: ActualWrapper): ActualWrapper

open operator fun plus(num: Number): ActualWrapper

rem

open operator fun rem(num: Number): ActualWrapper

open operator fun rem(other: ActualWrapper): ActualWrapper

times

open operator fun times(other: ActualWrapper): ActualWrapper

open operator fun times(num: Number): ActualWrapper

toList

fun <T> Tuple2<T>.toList(): List<T>

fun <T> Tuple3<T>.toList(): List<T>

fun <T> Tuple4<T>.toList(): List<T>

toPair

fun <A, B> Tuple.Tuple2d<A, B>.toPair(): Pair<A, B>

toSequence

fun <T> Tuple2<T>.toSequence(): Sequence<T>

fun <T> Tuple3<T>.toSequence(): Sequence<T>

fun <T> Tuple4<T>.toSequence(): Sequence<T>

toSet

fun <T> Tuple2<T>.toSet(): Set<T>

fun <T> Tuple3<T>.toSet(): Set<T>

fun <T> Tuple4<T>.toSet(): Set<T>

toTriple

fun <A, B, C> Tuple.Tuple3d<A, B, C>.toTriple(): Triple<A, B, C>