Contract calculator in Visitor pattern but simplied

ContractCalculation.kt

interface IContracts

interface ICalculator {
    fun calculate(vararg contracts: IContracts): Int
}

data class FixedPriceContract(
        val costPerYear: Int
) : IContracts


data class TimeAndMaterialsContract(
        val costPerHour: Int,
        val totalHours: Int
) : IContracts


data class SupportContract(
        val costPerMonth: Int
) : IContracts


object YearCostReportCalculator : ICalculator {
    override fun calculate(
            vararg contracts: IContracts
    ): Int {
        return contracts.map {
            when (it) {
                is FixedPriceContract -> it.costPerYear
                is TimeAndMaterialsContract -> it.costPerHour * it.totalHours
                is SupportContract -> it.costPerMonth * 12
                else -> throw NotImplementedError()
            }
        }.sum()
    }
}


object MonthCostReportCalculator : ICalculator {
    override fun calculate(
            vararg contracts: IContracts
    ): Int {
        return contracts.map {
            when (it) {
                is FixedPriceContract -> it.costPerYear / 12
                is TimeAndMaterialsContract -> it.costPerHour * it.totalHours
                is SupportContract -> it.costPerMonth
                else -> throw NotImplementedError()
            }
        }.sum()
    }
}


object SupportCostReportCalculator : ICalculator {
    override fun calculate(vararg contracts: IContracts): Int {
        return contracts.map {
            when (it) {
                is FixedPriceContract -> it.costPerYear / 12
                is TimeAndMaterialsContract -> it.costPerHour * it.totalHours
                is SupportContract -> it.costPerMonth
                else -> throw NotImplementedError()
            }
        }.sum()
    }
}