So im educating myself for the future
firstLetter :: IO String
firstLetter = do
x <- getChar
if (x == ' ')
then return (show x)
else firstLetter
So it would get lines until the first line, that starts with empty char
how can I do it, so if empty line comes, it returns all head(x)
for example:
Liquid
Osone
Liquid
(empty line)
returns
"LOL"
Try this. The library function lines will split the input into lines for you, so all that is left is extracting the first character from each string in a list until one string is empty. An empty string is just a null list, so you can check for that to end the recursion over the list of strings.
firstLetters :: [String] -> String
firstLetters (x:xs)
| null x = []
| otherwise = head x : firstLetters xs
main = do
contents <- getContents
putStrLn . firstLetters . lines $ contents
Have you seen interact? This'll help you eliminate the IO and that always seems to make thing simpler for me and hopefully you too.
That reduces it to a problem that reads a string and returns a string.
Here's a rough go at it. getLines takes a string, breaks it into lines and consumes them (takeWhile) until it meets a line containing a single space (I wasn't sure on your ending condition, as the other poster says using null will stop at the first empty list). Then it goes over those lines and gets the first character of each (with map head).
getLines :: String -> String
getLines = map head . takeWhile (/= " ") . lines
main :: IO ()
main = interact getLines
Related
I am new to Haskell and functional programing. I have a .txt file which contains some paragraphs. I want to count the number of words in each paragraph, using Haskell.
I have written the input/output code
paragraph-words:: String -> int
no_of_words::IO()
no_of_words=
do
putStrLn "enter the .txt file name:"
fileName1<- getLine
text<- readFile fileName1
let wordscount= paragraph-words text
Can anyone help me to write the function paragraph-words. which will calculate the number of words in each paragraph.
First: you don't want to be bothered with dirty IO() any more than necessary, so the signature should be
wordsPerParagraph :: String -> [Int]
As for doing this: you should first split up the text in paragraphs. Counting the words in each of them is pretty trivial then.
What you basically need is match on empty lines (two adjacent newline characters). So I'd first use the lines function, giving you a list of lines. Then you separate these, at each empty line:
paragraphs :: String -> [String]
paragraphs = split . lines
where split [] = []
split (ln : "" : lns) = ln : split lns
split (ln : lns) = let (hd, tl) = splitAt 1 $ split lns
in (ln ++ hd) : tl
A list of lines can be split into paragraphs if one takes all lines until at least one empty line ("") is reached or the list is exhausted (1). We ignore all consecutive empty lines (2) and apply the same method for the rest of our lines:
type Line = String
type Paragraph = [String]
parify :: [Line] -> [Paragraph]
parify [] = []
parify ls
| null first = parify rest
| otherwise = first : parify rest
where first = takeWhile (/= "") ls -- (1) take until newline or end
rest = dropWhile (== "") . drop (length first) $ ls
-- ^ (2) drop all empty lines
In order to split a string into its lines, you can simply use lines. To get the number of words in a Paragraph, you simply sum over the number of words in each line
singleParagraphCount :: Paragraph -> Int
singleParagraphCount = sum . map lineWordCount
The words in each line are simply length . words:
lineWordCount :: Line -> Int
lineWordCount = length . words
So all in all we get the following function:
wordsPerParagraph :: String -> [Int]
wordsPerParagraph = map (singleParagraphCount) . parify . lines
First, you can't use - in a function name, you would have to use _ instead (or better, use camelCase as leftroundabout suggests below).
Here is a function which satisfies your type signature:
paragraph_words = length . words
This first splits the text into a list of words, then counts them by returning the length of that list of words.
However this does not completely solve the problem because you haven't written code to split your text into paragraphs.
I have file txt which contain two numbers, for example:
2.
3.
How can you see, each end of line is ended with dot.
How can I read it and print for example sum of this numbers?
If my file don't contain dots, so for example I have
2
3
it isn't problem. My code is:
main3 = do
x <- openFile "C:/Users/file.txt" ReadMode
m <- hGetLine x
n <- hGetLine x
return ((read m::Int)+(read n::Int))
and it work good. But when in my file are dots, i don't know what can I do. Maybe are any library?
Thank's for help.
The trouble is that read won't parse "3." to mean 3. If you just want to do this in a hacky way, you can drop the last character.
main4 = do
x <- openFile "C:/Users/file.txt" ReadMode
m <- hGetLine x
n <- hGetLine x
return ((read (init m)::Int)+(read (init n)::Int))
which may work but is quite fragile since it assumes that the only non-digit character in each line is the last. We can do a little better by assuming the first n digit characters form our numbers
import Data.Char
-- takeWhile isDigit :: String -> String
main5 path = do
f <- readFile path
numberStrings <- map (takeWhile isDigit) (lines f)
sum (map read numberStrings)
The most robust solution would be to upgrade to a "parser combinator library" like Parsec which would let you write out the grammar of your text file.
There are a few ways to do it.. The simplest being
main = do
text <- readFile "file.txt" -- Grab the file
let nums = map read . map init . lines $ text
print $ sum nums
init just drops the .. However I'd write it like this
import Text.Parsec.String
import Text.Parsec
import Control.Applicative ((<*), (<$>))
getNums :: Parser [Int]
getNums = num `sepEndBy` newline
where num = read <$> many1 digit <* char '.'
main = parseFromFile getNums "filename" >>= print . fmap sum
Is it worth using parsec for something like this? The answer is "it depends". My rule of thumb is that if I'm planning to use it more than once, then just bite the bullet and use parsec. It's much, much easier to modify something that uses a library like parsec for new and more complex formats. Plus you get free [decent] error messages this way.
You can to this in several steps, exploiting Haskell's monadic API:
Read in the file line per line
Check whether each line is ended with a dot: Use map and return a Maybe monad: Nothing when the line is not ended with a dot, Just (value without dot) when the line ended with a dot
Use map + flatten to convert each String to a number, again with the Maybe monad. Nothing when there is an error, or Just x to contain the number
Sum the values using fold
When I have some time, I will try to build an example. It's always fun to play with Haskell's monadic API.
I am trying to write a function that gets multiple string inputs and terminates on an empty line ('\n') I have following
getLines :: IO [String]
getLines = do x <- getLine
if x == ""
return ()
else do xs <- getLines
return (x:xs)
it fails to compile saying there is something wrong with the if statement
Ideally I want to to work like this
getLines
Apple
Bird
Cat
(enter is pressed)
Output:
["Apple","Bird","Cat"]
You need then after if, and () (empty tuple) should be [] (empty list). In if, the then and else need to be indented as well if they’re on separate lines, because if then else is an operator, and the compiler needs to know that the expression continues. Your indentation needs to be adjusted so that everything is indented more than the leading do:
getLines :: IO [String]
getLines = do x <- getLine
if x == ""
then return []
else do xs <- getLines
return (x:xs)
Or everything is indented more than the line containing the leading do:
getLines :: IO [String]
getLines = do
x <- getLine
if x == ""
then return []
else do
xs <- getLines
return (x:xs)
As a matter of style, you can also use null x instead of x == "".
This is nearly right.
You need a then after your if. You may also need to change the indentation slightly, so that everything is indented as far as the x rather than the do. I think that should just about do it.
I keep getting an error: couldn't match expected type 'Bool' with actual type '[t0]'. I'm trying to get user inputs of string and then output however many strings in reversed ORDER.
Example input:
HI1
HI2
Example output:
HI2
HI1
My code:
Back :: Int -> IO()
Back x = do line <- sequence_[getLine|[1..x]]
mapM_ print (reverse line)
To expand on Vitus's comment, import Control.Monad, then
back count = do
lines <- replicateM count getLine
mapM_ putStrLn (reverse lines)
If this doesn't work for you, please say what error message you get, or give an example of incorrect output.
In this case, we can forego do notation fairly easily:
back count = mapM_ putStrLn . reverse =<< replicateM count getLine
Or
back count = mapM_ putStrLn =<< liftM reverse (replicateM count getLine)
You may or may not find either of those to be clearer.
Note that your function name must start with a lower case letter, e.g. back. Back as a function name is a syntax error.
Also note that indentation is significant. The indentation of the do block in your question is wrong; the do blocks in my and melpomene's answers are correctly indented.
back :: Int -> IO ()
back x = do line <- sequence [getLine | _ <- [1 .. x]]
mapM_ putStrLn (reverse line)
I'm trying to grab a random item from a string list and save that into another string list but I can't get my code to work.
import System.Random
import Control.Applicative ( (<$>) )
food = ["meatballs and potoes","veggisoup","lasagna","pasta bolognese","steak and fries","salad","roasted chicken"]
randomFood xs = do
if (length xs - 1 ) > 0 then
[list] <- (fmap (xs!!) $ randomRIO (0, length xs -1))
else
putStrLn (show([list])
I'm getting parse error on input '<-' but I'm sure there are more issues then that. There is also the issue that the list may contain the same dishes two days in a row which is not what I want and I guess I can remove duplicates but that also would remove the number of items in the list which I want to stay the same as the number in the list.
Anyone have a good idea how I could solve this? I have been searching for a day now and I can't find something useful for me but that's just because I'm looking in the wrong places. Any suggestion on how I can do this or where I can find the info will be greatly appreciated!
The reason it didn't work is that you needed another do after your if...then. (After a then you need an expression, not a pattern <- expression.)
randomFood :: String -> IO () -- type signature: take a String and do some IO.
randomFood xs = do
if length xs > 1 then do
[list] <- (fmap (xs!!) $ randomRIO (0, length xs -1))
else
putStrLn (show([list])
But that still doesn't compile, because you don't actually do anything with your list.
At the end of every do block, you need an expression to return.
I think you meant to still print some stuff if the length of xs is too short, and you probably meant to print the selected food if there was more than one to choose from.
Better would be:
randomFood :: String -> IO ()
randomFood xs | length xs <= 1 = putStrLn $ show xs
randomFood xs | otherwise = do
item <- (xs!!) <$> randomRIO (0, length xs -1)
putStrLn $ show(item)
This | boolean test = syntax is better for conditional answers based on input.
I changed [list] to item because you're selecting a single item randomly, not a list of items.
Haskell is quite happy to let you put [list], because any string that's got one character in it matches [list].
For example, "h" = [list] if list='h', because "h" is short for ['h']. Any longer string will give you Pattern match failure. In particular, all the food you've specified has more than one character, so with this definition randomFood would never work! item will match anything returned by your randomRIO expression, so that's fine.
You imported <$> then didn't use it, but it's a nice operator, so I've replaced fmap f iothing with f <$> iothing.
I finally realised I'm doing the wrong thing with short lists; if I do randomFood ["lump of cheese"] I'll get ["lump of cheese"], which is inconsistent with randomFood ["lump of cheese"] which will give me "lump of cheese".
I think we should separate the short list from the empty list, which enables us to do more pattern matching and less boolean stuff:
randomFood :: String -> IO ()
randomFood [] = putStrLn "--No food listed, sorry.--"
randomFood [oneitem] = putStrLn . show $ oneitem
randomFood xs = do
item <- (xs!!) <$> randomRIO (0, length xs -1)
putStrLn . show $ item
This gives three different definitions for randomFood depending on what the input looks like.
Here I've also replaced putStrLn (show (item)) with putStrLn . show $ item - compose the functions show and putStrLn and apply ($) that to the item.
Few points to note :
Don't intermix pure and impure code.
Try to use library for a task rather than repeating what is already written.
Here is the code using random-fu library
import Data.Random
import Control.Applicative
food :: [String]
food = ["meatballs and potoes","veggisoup","lasagna","pasta bolognese","steak and fries","salad","roasted chicken"]
randomFood :: [String] -> RVar (Maybe String)
randomFood [] = return Nothing
randomFood xs = Just <$> randomElement xs
main :: IO ()
main = (sample $ randomFood food) >>= print
This is like choosing one element from a list randomly.
> main
Just "steak and fries"
> main
Just "meatballs and potoes"
If you want to output just a random permutation of the above list, you can use shuffle like
main = (sample $ shuffle food) >>= print
Example
> main
["meatballs and potoes","lasagna","steak and fries","roasted chicken","salad","pasta bolognese","veggisoup"]
> main
["roasted chicken","veggisoup","pasta bolognese","lasagna","steak and fries","meatballs and potoes","salad"]