commons-provider/xyz.xenondevs.commons.provider/MutableProvider/decompose

decompose

abstract fun <R> decompose(size: Int, decompose: (T) -> List<R>, recompose: (List<R>) -> T): List<MutableProvider<R>>

Decomposes this into a list of size MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B> decompose(decompose: (T) -> Tuple2<A, B>, recompose: (A, B) -> T): Tuple2<MutableProvider<A>, MutableProvider<B>>

Decomposes this into two MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C> decompose(decompose: (T) -> Tuple3<A, B, C>, recompose: (A, B, C) -> T): Tuple3<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>>

Decomposes this into three MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C, D> decompose(decompose: (T) -> Tuple4<A, B, C, D>, recompose: (A, B, C, D) -> T): Tuple4<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>, MutableProvider<D>>

Decomposes this into four MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C, D, E> decompose(decompose: (T) -> Tuple5<A, B, C, D, E>, recompose: (A, B, C, D, E) -> T): Tuple5<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>>

Decomposes this into five MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C, D, E, F> decompose(decompose: (T) -> Tuple6<A, B, C, D, E, F>, recompose: (A, B, C, D, E, F) -> T): Tuple6<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>>

Decomposes this into six MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C, D, E, F, G> decompose(decompose: (T) -> Tuple7<A, B, C, D, E, F, G>, recompose: (A, B, C, D, E, F, G) -> T): Tuple7<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>>

Decomposes this into seven MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C, D, E, F, G, H> decompose(decompose: (T) -> Tuple8<A, B, C, D, E, F, G, H>, recompose: (A, B, C, D, E, F, G, H) -> T): Tuple8<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>>

Decomposes this into eight MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C, D, E, F, G, H, I> decompose(decompose: (T) -> Tuple9<A, B, C, D, E, F, G, H, I>, recompose: (A, B, C, D, E, F, G, H, I) -> T): Tuple9<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>, MutableProvider<I>>

Decomposes this into nine MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).

abstract fun <A, B, C, D, E, F, G, H, I, J> decompose(decompose: (T) -> Tuple10<A, B, C, D, E, F, G, H, I, J>, recompose: (A, B, C, D, E, F, G, H, I, J) -> T): Tuple10<MutableProvider<A>, MutableProvider<B>, MutableProvider<C>, MutableProvider<D>, MutableProvider<E>, MutableProvider<F>, MutableProvider<G>, MutableProvider<H>, MutableProvider<I>, MutableProvider<J>>

Decomposes this into ten MutableProviders using the provided decompose and recompose functions.

decompose and recompose should be pure functions whose components are independent: modifying one component and round-tripping through recompose and decompose must not alter any other component. This allows updating a single component without invalidating its siblings.

The returned providers will only be stored in a WeakReference in the parent provider (this).