Haskell - Validate integer input from string using readMaybe - validation

Question

I am trying to validate integer input from a string, I just need a boolean result if the input string correctly changes types to an integer. I tried this method from another question:
https://stackoverflow.com/a/30030649/3339668
This is the relevant code along with my imports:
import Data.Char
import Data.List
import Text.Read
checkValidInt :: String -> Bool
checkValidInt strInt
| readMaybe strInt :: Maybe Int == Nothing = False
| readMaybe strInt :: Maybe Int /= Nothing = True
However, I receive the following errors on loading the script:
Illegal operator ‘==’ in type ‘Maybe Int == Nothing’
Use TypeOperators to allow operators in types
main.hs:350:38:
Not in scope: type constructor or class ‘Nothing’
A data constructor of that name is in scope; did you mean DataKinds?
main.hs:351:35:
Illegal operator ‘/=’ in type ‘Maybe Int /= Nothing’
Use TypeOperators to allow operators in types
main.hs:351:38:
Not in scope: type constructor or class ‘Nothing’
A data constructor of that name is in scope; did you mean DataKinds?
So what kind of data type is Nothing? How do I check if Nothing is the result of readMaybe properly?

Answer 1

This is due to the fact that Haskell interprets your
readMaybe strInt :: (Maybe Int == Nothing = False)
as:
readMaybe strInt :: (Maybe Int == Nothing = False)
It can make no sense out of this. So you can help Haskell by using some brackets:
(readMaybe strInt :: Maybe Int) == Nothing = False
You also better do not repeat the condition, but use otherwise, since if you repeat it, the program will - unless optimized - do the parsing twice, so:
checkValidInt :: String -> Bool
checkValidInt strInt
| (readMaybe strInt :: Maybe Int) == Nothing = False
| otherwise = True
Since you check for a condition such that the result is True if the condition is False, and vice versa, it is no use to use guards, we can write it as:
checkValidInt :: String -> Bool
checkValidInt strInt = Nothing /= (readMaybe strInt :: Maybe Int)
Or we can use a pattern guard, this can be used in case we can not perform equality checks on the type of value that is wrapped in the Maybe, so:
checkValidInt :: String -> Bool
checkValidInt strInt | Just _ <- (readMaybe strInt :: Maybe Int) = True
| otherwise = False
Or we can use the isJust :: Maybe a -> Bool function:
checkValidInt :: String -> Bool
checkValidInt strInt = isJust (readMaybe strInt :: Maybe Int)

Answer 2

I just need a boolean result
Probably not. You need a Maybe Int to pattern match on, and readMaybe already gives you that without any further processing.
Instead of this
if checkValidInt s -- try reading an Int, but throw it away
then foo (read s) -- now really read an Int and use it
else bar -- fall back
you do this
case readMaybe s of -- try reading an Int
Just i -> foo i -- use it
Nothing -> bar -- fall back
Normally an explicit type annotation should not be needed, if foo is of the right type; but see below.
If you, for some unfathomable reason, really need checkValidInt, you base it on the above pattern
case (readMaybe s) :: Maybe Int of
Just _ -> True
Nothing -> False
As noted in another answer, the maybe function abstracts this pattern match away, but I would recommend using explicit pattern matches whenever you can as an exercise, to get the hang of it.

Answer 3

You could rewrite this as
import Data.Char
import Data.List
import Text.Read
checkValidInt :: String -> Bool
checkValidInt strInt =
case (readMaybe strInt :: Maybe Int) of
Nothing -> False
Just _ -> True

Answer 4

The algorithm you need here has already been abstracted behind the maybe function:
checkValidInt :: String -> Bool
checkValidInt = maybe False (const True) . (readMaybe :: String -> Maybe Int)
If readMaybe returns Nothing, then maybe returns False. Otherwise, it just applies const True to the resulting Just value, which returns True without caring about just what is wrapped by Just. Note that you are specializing the type of readMaybe itself, not the type of its return value.
Or, even simpler with an import,
import Data.Maybe
checkValidInt :: String -> Bool
checkValidInt = isJust . (readMaybe :: String -> Maybe Int)