Yes, it is certainly possible to display only certain rows. If you want to base it off of the row number, the easiest way is to use zip
and filter
type Record = String
onlyEven :: [Record] -> [Record]
onlyEven records =
map snd $ -- Drop the numbers and return the remaining records
filter (even . fst) $ -- Filter by where the number is even
zip [1..] -- All numbers
records -- Your records
This technique can be used in a lot of circumstances, you could even abstract it a bit to
filterByIdx :: Integral i => (i -> Bool) -> [a] -> [a]
filterByIdx condition xs = map snd $ filter (condition . fst) $ zip [1..] xs
-- Could also use 0-based of `zip [0..] xs`, up to you
onlyEven :: [a] -> [a]
onlyEven = filterByIdx even
If you want to check if an input is an Int
, the easiest way is to use the Text.Read.readMaybe
function:
import Text.Read (readMaybe)
promptUntilInt :: IO Int
promptUntilInt = do
putStr "Enter an integer: "
response <- getLine
case readMaybe response of
Just x -> return x
Nothing -> do
putStrLn "That wasn't an integer!"
promptUntilInt
This should give you an idea of how to use the function. Note that in some cases you'll have to specify the type signature manually as case (readMaybe response :: Maybe Int) of ...
, but here it'll work fine because it can deduce the Int
from promptUntilInt
's type signature. If you get an error about how it couldn't figure out which instance for Read a
to use, you need to manually specify the type.
You have
something <- getLine
return (read something:: Int)
let response = check something
putStrLn response
To step through what you're trying to do with these lines:
something <- getLine
getLine
has the type IO String
, meaning it performs an IO
action and returns a String
. You can extract that value in do
notation as
something <- getLine
Just as you have above. Now something
is a String
that has whatever value was entered on that line. Next,
return (read something :: Int)
converts something
to an Int
, and then passes it to the function return
. Remember, return
is not special in Haskell, it's just a function that wraps a pure value in a monad. return 1 :: Maybe Int === Just 1
, for example, or return 1 :: [Int] === [1]
. It has contextual meaning, but it is no different from the function putStrLn
. So that line just converts something
to an Int
, wraps it in the IO
monad, then continues on to the next line without doing anything else:
let response = check something
This won't compile because check
has the type Int -> Int
, not String -> String
. It doesn't make any sense to say "hello, world" > 0 && "hello, world" <= 10
, how do you compare a String
and an Int
? Instead, you want to do
let response = check (read something)
But again, this is unsafe. Throwing an error on an invalid read or when read something
is greater than 10 will crash your program completely, Haskell does errors differently than most languages. It's better to do something like
check :: Int -> Bool
check a = a > 0 && a <= 10
...
something <- getLine
case readMaybe something of
Nothing -> putStrLn "You didn't enter a number!"
Just a -> do
if check a
then putStrLn "You entered a valid number!"
else putStrLn "You didn't enter a valid number!"
putStrLn "This line executes next"
While this code is a bit more complex, it's also safe, it won't ever crash and it handles each case explicitly and appropriately. By the way, the use of error
is usually considered bad, there are limited capabilities for Haskell to catch errors thrown by this function, but errors can be represented by data structures like Maybe
and Either
, which give us pure alternatives to unsafe and unpredictable exceptions.
Finally,
putStrLn response
If it was able to compile, then response
would have the type Int
, since that's what check
returns. Then this line would have a type error because putStrLn
, as the name might suggest, puts a string with a new line, it does not print Int
values. For that, you can use print
, which is defined as print x = putStrLn $ show x
Since this is somewhat more complex, I would make a smaller function to handle it and looping until a valid value is given, something like
prompt :: Read a => String -> String -> IO a
prompt msg failMsg = do
putStr msg
input <- getLine
case readMaybe input of
Nothing -> do
putStrLn failMsg
prompt
Just val -> return val
Then you can use it as
main = do
-- other stuff here
-- ...
-- ...
(anInt :: Int) <- prompt "Enter an integer: " "That wasn't an integer!"
-- use `anInt` now
if check anInt
then putStrLn $ "Your number multiplied by 10 is " ++ show (anInt * 10)
else putStrLn "The number must be between 1 and 10 inclusive"
You don't have to make it so generic, though. You could easily just hard code the messages and the return type like I did before with promptUntilInt
.