Compositions.kt

fun invoicePath(
    config: ProcessConfiguration,
    invoiceMap: InvoiceConfig = invoiceConfiguration,
    shippingMap: ShippingConfig = shippingConfiguration,
    freightMap: FreightConfig = freightCostConfiguration
) = invoiceMap[config.invoiceChoice]!!
    .compose(shippingMap[config.shippingChoice]!!)
    .compose(freightMap[config.freightChoice]!!)

fun availabilityPath(
    config: ProcessConfiguration,
    availabilityMap: AvailabilityConfig = availabilityConfiguration,
    shippingDateMap: ShippingDateConfig = shippingDateConfiguration
) = availabilityMap[config.availabilityChoice]!!
    .compose(shippingDateMap[config.shippingDateChoice]!!)

fun <T1, T2, T3> ((T1) -> T2).compose(func: (T2) -> T3): (T1) -> T3 = { func(this(it)) }

Entities.kt

typealias InvoiceConfig = Map<InvoiceChoice, (Order) -> Invoice>
typealias ShippingConfig = Map<ShippingChoice, (Invoice) -> Shipping>
typealias FreightConfig = Map<FreightChoice, (Shipping) -> FreightCost>
typealias AvailabilityConfig = Map<AvailabilityChoice, (Order) -> Availability>
typealias ShippingDateConfig = Map<ShippingDateChoice, (Availability) -> ShippingDate>


enum class ShippingDateChoice {
    SHIP_DATE1,
    SHIP_DATE2,
}

enum class InvoiceChoice {
    INV1,
    INV2
}

enum class FreightChoice {
    FR1,
    FR2
}

enum class ShippingChoice {
    SHIP1,
    SHIP2
}

enum class AvailabilityChoice {
    AV1,
    AV2
}

data class ProcessConfiguration(
    val shippingDateChoice: ShippingDateChoice,
    val invoiceChoice: InvoiceChoice,
    val freightChoice: FreightChoice,
    val shippingChoice: ShippingChoice,
    val availabilityChoice: AvailabilityChoice
)

data class Order(val hello: Unit)
data class Invoice(val hello: Unit)
data class Shipping(val hello: Unit)
data class FreightCost(val hello: Unit)
data class Availability(val hello: Unit)
data class ShippingDate(val hello: Unit)

Functions.kt

fun adjustCoast(
    freightCoast: (Order) -> FreightCost,
    shippingDate: (Order) -> ShippingDate
): (Order) -> Double = { 0.0 }

fun inv1(order: Order)=Invoice(Unit)
fun inv2(order: Order)=Invoice(Unit)

fun ship1(invoice: Invoice)=Shipping(Unit)
fun ship2(invoice: Invoice)=Shipping(Unit)

fun fr1(shipping: Shipping)=FreightCost(Unit)
fun fr2(shipping: Shipping)=FreightCost(Unit)

fun av1(order: Order)=Availability(Unit)
fun av2(order: Order)=Availability(Unit)

fun shipDate1(availability: Availability) = ShippingDate(Unit)
fun shipDate2(availability: Availability) = ShippingDate(Unit)

Main.kt

val configuration = ProcessConfiguration(
    ShippingDateChoice.SHIP_DATE1,
    InvoiceChoice.INV1,
    FreightChoice.FR1,
    ShippingChoice.SHIP1,
    AvailabilityChoice.AV1
)
val invoicePath = invoicePath(configuration)
val availabilityPath = availabilityPath(configuration)
val calcAdjustedCostForOrder = adjustCoast(invoicePath, availabilityPath)

fun main() {
    calcAdjustedCostForOrder(Order(Unit)).also(::println)
}

ProcessConfigurations.kt

val invoiceConfiguration = mapOf<InvoiceChoice, (Order) -> Invoice>(
    Pair(InvoiceChoice.INV1, ::inv1),
    Pair(InvoiceChoice.INV2, ::inv2)
)
val shippingConfiguration = mapOf<ShippingChoice, (Invoice) -> Shipping>(
    Pair(ShippingChoice.SHIP1, ::ship1),
    Pair(ShippingChoice.SHIP2, ::ship2)
)

val freightCostConfiguration = mapOf<FreightChoice, (Shipping) -> FreightCost>(
    Pair(FreightChoice.FR1,::fr1),
    Pair(FreightChoice.FR2,::fr2)
)

val availabilityConfiguration = mapOf<AvailabilityChoice, (Order) -> Availability>(
    Pair(AvailabilityChoice.AV1,::av1),
    Pair(AvailabilityChoice.AV2,::av2)
)

val shippingDateConfiguration = mapOf<ShippingDateChoice, (Availability) -> ShippingDate>(
    Pair(ShippingDateChoice.SHIP_DATE1,::shipDate1),
    Pair(ShippingDateChoice.SHIP_DATE2,::shipDate2)
)