How to make a Haskell function calculate ticket prices? - haskell

Question

I am new to Haskell and am trying to write a function that does the following:
asks user to enter "Youth" "Adult" or "Senior" and indicate of the one they pick
function then calculates total price of tickets (Y = $10.50, A = $20, S = $15)
Sample output:
Enter type of ticket and count:
Senior 7
Total price is: 95.00
Here is what I have come up with so far:
calcPrice :: (String a) => a -> b -> b
calcPrice x y =
if x == "Youth"
then "Total price :" ++ 10.5 * y
else if x == "Adult"
then "Total price :" ++ 20 * y
else if x == "Senior"
then "Total price :" ++ 15 * y
else "Invalid input."
...but I get this error:
homework8.hs:31:15: error:
• Expected kind ‘* -> Constraint’, but ‘String’ has kind ‘*’
• In the type signature: calcPrice :: (String a) => a -> b -> b
|
31 | calcPrice :: (String a) => a -> b -> b |
Any help is appreciated, but my main questions are:
How do we specify the types if we want to output a string and a number?
In other variants, an error message appeared that it was not happy about the comparison in the if/else if statements. why?
How do I make the function output something if it can only be called with arguments that the user has no idea to input until the message is displayed?
EDIT_________________
Here is the new code after making the changes you all have mentioned:
calcPrice :: (Integral a) => String -> a -> String
calcPrice x y =
if x == "Youth"
then "Total price :" ++ Show(10.5 * y)
else if x == "Adult"
then "Total price :" ++ Show(20 * y)
else if x == "Senior"
then "Total price :" ++ Show(15 * y)
else "Invalid input."
and I now get this error...
homework8.hs:34:31: error:
• Data constructor not in scope: Show :: a -> [Char]
• Perhaps you meant variable ‘show’ (imported from Prelude)
|
34 | then "Total price :" ++ Show(10.5 * y) | ^^^^
homework8.hs:36:31: error:
• Data constructor not in scope: Show :: a -> [Char]
• Perhaps you meant variable ‘show’ (imported from Prelude)
|
36 | then "Total price :" ++ Show(20 * y) | ^^^^
homework8.hs:38:31: error:
• Data constructor not in scope: Show :: a -> [Char]
• Perhaps you meant variable ‘show’ (imported from Prelude)
|
38 | then "Total price :" ++ Show(15 * y) | ^^^^
Failed, no modules loaded.

Answer 1

How do we specify the types if we want to output a string and a number?
One way is to give back a tuple of a string and a number:
calcPrice :: String -> Double -> (String, Double)
calcPrice x y =
if x == "Youth"
then ("Total price :", 10.5 * y)
else if x == "Adult"
then ("Total price :", 20 * y)
else if x == "Senior"
then ("Total price :", 15 * y)
else ("Invalid input.", 0/0)
However, as the comments pointed out, in this case it's probably more sensible to encode and append the number part into the string. Conversion from many types to String is easily done with the show function (which is a method of the Show (uppercase) typeclass – note how the show function you use in your value level code is lowercase)
calcPrice :: String -> Double -> String
calcPrice x y =
if x == "Youth"
then "Total price :" ++ show (10.5 * y)
else if x == "Adult"
then "Total price :" ++ show (20 * y)
else if x == "Senior"
then "Total price :" ++ show (15 * y)
else "Invalid input."
The other sub-questions are unclear to me – maybe remove them here and flesh them out as separate questions.
Some stylistic remarks:
Rather than doing a bunch of separate if x== statements, it's neater and in general also more efficient to use case (which is very flexible in Haskell, and often works even for types that can't be equality-compared):
calcPrice x y = case x of
"Youth" -> "Total price :" ++ show (10.5 * y)
"Adult" -> "Total price :" ++ show (20 * y)
"Senior" -> "Total price :" ++ show (15 * y)
_ -> "Invalid input."
Alternative syntax for the same thing: you can simply write a bunch of separate function clauses for specific values of x, rather than only one that accepts any x
calcPrice "Youth" y = "Total price :" ++ show (10.5 * y)
calcPrice "Adult" y = "Total price :" ++ show (20 * y)
calcPrice "Senior" y = "Total price :" ++ show (15 * y)
calcPrice _ _ = "Invalid input."
Not just in Haskell, but any language it's good to follow the DRY principle. A standard way of this is to define local variables, like
calcPrice x y = case x of
"Youth" -> totalPrice ++ show (10.5 * y)
"Adult" -> totalPrice ++ show (20 * y)
"Senior" -> totalPrice ++ show (15 * y)
_ -> "Invalid input."
where totalPrice = "Total price :"
don't do it this way, because the actual code-duplication (++ show, * y) is still there! Instead, define local functions (which are also variables)
calcPrice x y = case x of
"Youth" -> priceMul 10.5
"Adult" -> priceMul 20
"Senior" -> priceMul 15
_ -> "Invalid input."
where priceMul μ = "Total price :" ++ show (μ*y)
In a bigger project you should probably separate the “is the input valid?” from the actual calculation logic, else you'll soon have weird errors popping up deep in your code where you never expected them. Worse, if the error is merely “signalled” by a dedicated string value "Invalid input", it becomes very difficult to find where the error did happen.
Advocates of dynamic languages argue that this is what unit tests are there for, but a static type system reduces the need for that a lot. Specifically, you can accept instead of a string which could easily have lots of invalid values, a type that only has those values that are actually valid:
data PricingTier = Youth | Adult | Senior
calcPrice :: PricingTier -> Double -> String
calcPrice x y = case x of
Youth -> priceMul 10.5
Adult -> priceMul 20
Senior -> priceMul 15
where priceMul μ = "Total price :" ++ show (μ*y)