How do I get multiple params from user in haskell?
module Main where
main :: IO ()
main = do
putStrLn "Please enter param1: "
param1 <- getLine
putStrLn "Please enter param2: "
param2 <- getLine
putStrLn $ "you entered" ++ param1 ++ "param 2:" ++ param2
I am using http://www.compileonline.com/compile_haskell_online.php to feed in params.
I am not sure if the program is wrong or the STDINPUT is not fine.
can someone guide me here.
All I get this is this :
Please enter param1: Please enter param2: demo: : hGetLine:
end of file
The output is not even printed.
STDIN Input: 123 231
Your compileonline.com site does not support multiple lines in stdin. If you remove the second getLine and param2 your program works.
The error you are seeing relates to stdin being closed before the second getLine is completed.
Any site that spells it 'Haskel' is probably not a good one.
It looks like the input is 1 line, while you're expecting 2 lines. Either put the input on two lines or change your code to be
module Main where
main :: IO ()
main = do
line <- getLine
let
params = words line
param1 = params !! 0
param2 = params !! 1
putStrLn $ "you entered" ++ param1 ++ "param 2:" ++ param2
This takes the single line of stdin and splits it by space.
Related
This question already has an answer here:
Wrong IO actions order using putStr and getLine
(1 answer)
Closed 5 years ago.
When I want to put some text before reading an input in Haskell, I tried writing it like this:
putStr "enter value: "
var <- getLine
However the output requires the user input before it displays the text:
[input]
enter value:
When I use putStrLn instead of putStr, it displays as it should:
enter value:
[input]
Why do these two statements function differently? Is it the addition of the newline?
putStr "enter value: " actually writes to an output buffer, which is flushed to the actual standard output only later on, when the buffer becomes full or when a newline is found.
This is roughly the same mechanism found in the C programming language.
So, even if putStr "enter value: " is run before getLine, we don't see the output message, yet, which feels wrong.
The solution is to flush the standard output handle explicitly.
import System.IO
-- ...
putStr "enter value: "
hFlush stdout
var <- getLine
The following snippet of code executes a grep command and binds the output to stdout', stderr' and errCode respectively.
main :: IO ()
main = do
let stdin' = ""
(errCode, stdout', stderr') <- readProcessWithExitCode "grep" ["search-term" ,"-nr", "/path/to/be/searched"] stdin'
putStrLn $ "stdout: " ++ stdout'
putStrLn $ "stderr: " ++ stderr'
putStrLn $ "errCode: " ++ show errCode
The problem is that stdout' only captures the first result of the search. I think this is because grep is something akin to a spawned process that feeds search results one file by one file until it is finished.
Question: I need the entire output of the standard output of grep to be binded to stdout'. Is this possible in Haskell, and if so, what is an idiomatic way to do it?
EDIT: It turns out that the issue wasn't as I thought it was. Namely, I had only one file in my directory that wasn't symlinked. I forgot to use -R as an option with grep, and so those symlinks weren't being traversed in the search! The issue has been resolved.
I'm trying to write some code which runs grep externally, then analyses the output. Specifically, I want to do
grep <username> *.test
but, sadly,
readProcess "grep" [username, "*.test"]
seems to generate the command with double quotes around the arguments
grep "<username>" "*.test"
and as there is no individual file called asterisk-dot-test, grep barfs. There are files with .test extensions.
Can I persuade readProcess (or something similar) to issue the command I want?
"*" is expanded not by grep, but by shell. You should run something like sh -c 'grep username *.test if you want the expansion.
A better way is to use createProcess with ShellCommand argument.
You're probably best going to createProcess, which is the most general process creation function. Something like...
import System.Process
import System.IO
makeGrep username file = "grep " ++ username ++ " " ++ file
main :: IO ()
main = do
(_, Just hOut, _, hProc) <- createProcess (
(shell (makeGrep "bob" "*.test"))
{ std_out = CreatePipe }
)
exitCode <- waitForProcess hProc
output <- hGetContents hOut
print output
I usually use system from System.Cmd. You're supposed to build a correct Shell command (e.g. do all the escaping) but it has the advantage that it uses the String as it's provided.
I have a main function that does a lot of IO. At one point, however, I want to check a variable like not (null shouldBeNull) exit the whole program, without continuing, with a linux exitcode 1 and output an error message.
I've tried playing around with error "..." like putting that in an if:
if (not (null shouldBeNull)) error "something bad happened" else putStrLn "ok"
but I get a parse error (possibly incorrect indentation) :(.
Here's an altered snippet.
main :: IO ExitCode
main = do
--Get the file name using program argument
args <- getArgs
file <- readFile (args !! 0)
putStrLn("\n")
-- ... (some other io)
-- [DO A CHECK HERE], exit according to check..
-- ... (even more io)
echotry <- system "echo success"
rmtry <- system "rm -f test.txt"
system "echo done."
As you may notice, I want to do the check where I've put [DO A CHECK HERE] comment above...
Thanks for your help!
The parse error is because you're missing the then keyword in your if expression.
if condition then truePart else falsePart
For exiting, a more appropriate choice than error might be to use one of the functions from System.Exit, for example exitFailure.
So for example,
if not $ null shouldBeNull
then do putStrLn "something bad happened"
exitFailure
else putStrLn "ok"
I'm trying to get the GET and the POST from the Happstack tutorial into one handler function so it's always together, which I've kind of achieved, but it seems ugly.
login :: ServerPart Response
login = msum [
do methodM POST
user <- look "user"
pass <- look "pass"
success <- query $ CheckPassword user pass
ok $ toResponse (user ++ ", " ++ pass ++ ": " ++ (if success then "Valid" else "Invalid")),
ok $ toResponse $ html $ do
B.head $ do
title "Login Form"
B.body $ do
form ! enctype "multipart/form-data" ! B.method "POST" $ do
B.label "user: " >> input ! type_ "text" ! name "user" ! size "10"
B.label "pass: " >> input ! type_ "text" ! name "pass" ! size "10"
input ! type_ "submit" ! name "upload"]
Things I'd like to change are:
Explicitly call out methodM GET rather than just have it be the fallthough.
Pull out the redundant ok $ toResponse and have that only in one place.
Preferably have the POST return HTML as well.
Anything else that looks "off" to anyone with more experience. Any ideas?
UPDATE: figured out #1; adding do methodM GET above the ok $ toResponse $ ... works fine, but the thing for newbies like me to note is that must line up vertically, i.e., the m in methodM needs to be directly above the o in ok. Hopefully this saves someone hours of frustration.
UPDATE 2: #3 was fairly easy -- just update the last line of the POST to be ok $ toResponse $ html $ do B.body $ toHtml $ user ++ ...
Look up formlets (they work with Happstack) and/or digestive-functors (which work with Snap and maybe even Happstack):
http://hackage.haskell.org/package/formlets
http://hackage.haskell.org/package/digestive-functors
I haven't investigated how digestive-functors are better than formlets but it's newer package and might be simpler than the old one.
There are some examples
There's even a library in F# that compiles to JavaScript and does similar thing on client side. It allowes checking things like login availability from JS while still being written in nice formlet/functional style. It's called WebSharper:
WebSharper