# Haskell - Tax Tariff - Part Two

Table of Content

### Alternative Calculation

Just like what I said in previous, there is other way to calculate.

``````Flatly

0 until 50  million:  5%
>  50 until 250 million: 15% -  5 million
> 250 until 500 million: 25% - 30 million
> 500 million          : 30% - 55 million``````

This will hold the same result as previous:

``````  50 million:   2.5 million
250 million:  32.5 million
500 million:  95   million
1000 million: 245   million``````

#### Infographic Chart

The math for above equation derived as shown in figure below: ### Haskell Code

#### Guard and Recursive

We can simply rephrase the previous function, as below to get the code done:

``````-- taxable income
pkp :: Int
pkp = 1000000000

-- income tax using progressive tariff
pph :: Int -> Int
pph pkp = round(pkpr pkp)
where
pkp_d  = fromIntegral(pkp)
pkpr pkp
| pkp <=  50000000 = pkp_d * 0.05
| pkp <= 250000000 = pkp_d * 0.15 -  5000000
| pkp <= 500000000 = pkp_d * 0.25 - 30000000
| otherwise        = pkp_d * 0.30 - 55000000

main = putStrLn \$ show \$ pph pkp``````

Code above will also result as below

``245000000``

The code is very nice and intuitive. The only isuuse here is there are too many constant.

Can we make it simpler ?

#### Separating Constants

By taking out the constant, we can prepare this code below:

``````[t1, t2, t3, t4] = map (*million) [0, 50, 250, 500]
(d1, d2, d3, d4) = (0, 5, 30, 55)
[dj1, dj2, dj3, dj4] = [fromIntegral(x * million) | x <- [d1, d2, d3, d4]]
pkp_d   = fromIntegral(pkp)
million = 1000000``````

Or in a more complete fashion, put the prepared constant inside `where` clause.

``````-- taxable incomes
pkps :: [Int]
pkps = [10^7, 10^8, 10^9]

-- income tax using progressive tariff
pph :: Int -> Int
pph pkp = round(pkpr pkp)
where
pkpr pkp
| pkp > t4 = pkp_d * p4 - d4
| pkp > t3 = pkp_d * p3 - d3
| pkp > t2 = pkp_d * p2 - d2
| pkp > t1 = pkp_d * p1 - d1
-- guard limit
[t1, t2, t3, t4] = map (*million) [0, 50, 250, 500]
-- tariff rate in percent
(p1, p2, p3, p4) = (0.05, 0.15, 0.25, 0.30)
-- difference, in million rupiah
[d1, d2, d3, d4] = map (fromIntegral . (*million)) [0, 5, 30, 55]
-- Typecast, such as to Double
pkp_d  = fromIntegral(pkp)
-- to avoid typo in writing digit
million   = 1000000

main = print \$ map pph pkps``````

Code above will result a list as below

``[500000,10000000,245000000]``

Oouuch… the code look ugly. and it lost the intuitive feels.

Am I fail yet ?

### What is Next ?

We can get rid of the guard. Consider continue reading [ Haskell - Tax Tariff - Part Three ].

Thank you for visiting.