Program error prelude read no parse

getting error Prelude.read: no parse

I am very new in haskell, i wrote the code for item details and search the detail for each item.

code for search

but, the problem is, it is working good for single data, if i append another data, then it showing error Prelude.read: no parse when i am trying to search the item. Help will be appreciated !!

1 Answer 1

Your problem is in the format of your data file. After one use of textfile , the file contains the following:

That’s a good list, and it works. After the second use of textfile , the file contains the following:

That’s not a good list, and it fails. You can see this in ghci :

It’s clear that read expects a single list, not two lists following each other.

If you want to append to a file that contains a single Haskell list, you need to read the file, append to the list, and write the new list in the file as a replacement.

This is a little tricky because of two tings:

• readFile is lazy, and writeFile to the same file can fail unless one makes sure that the whole file has already been read. In the function above this is solved by asking for the length of the new string before writing the file (the seq function makes sure that the length is computed before the write operation happens).
• the file may not exist, the catch clause is used above to handle that exceptional case.

Источник

*** Exception: Prelude.read: no parse in Haskell — Parsing, Expressions and Recursion

This portion of code should read in two or more numbers (main io function omitted), then a «+» to give the sum. Rationals are used because later i will do multiplications and such other operations.

The (second) error is with the parse function unable to handle

I have looked on the Data.Ratio page and on the web for this solution but haven’t found it and would appreciate some help. Thanks,

1 Answer 1

The first equation,

since per the type signature, a and b already are Expression s.

Or, in line with the second and third equations, change the type to

and change the first equation to

Two possible ways of fixing the code (there were more problematic parts):

The latter is rather circumspect, since in the end a Double is produced, there’s no real point using Rational s for the stack.

In your code for parse , the third equation leaves out the conversion of a Rational to an Expression via the Number constructor, but is otherwise fine. The second equation, however, contains a different type of problem:

If answer is either an Expression or a Rational , show answer cannot be parsed as a Float , so that will lead to a runtime error, as exemplified by your edit:

The (second) error is with the parse function unable to handle

At the point where the second equation is used, the first element ( answer ) on the stack is Number (3 % 1) , and show (Number (3 % 1)) is «Number (3 % 1)» , which is not a String that read can parse as a Float .

Источник

Haskell Exception: Prelude.read: no parse

I am new to Haskell, kinda 2 days since I study Haskell, and I want to do a project with files. I did it already in c++ and now I want to do it in Haskell too. A little part of project is about a library, where I can register a book and a person. Now I want to put book code into a file.txt but to store it as int, not as String, because I have to search and compare this code , with other codes later, and will be easier to compare. Here is my code, and I receive the following error *** Exception: Prelude.read: no parse. Does anyone know how to solve this please?

1 Answer 1

This fails since you’re attempting to read a String as a String.

read is used to parse a String as an object. To parse a String as a String though, you need to add explicit quotes around the String being parsed. Failing to do so will result in the error that you got. You can test this by adding » s around the input when your program asks for it. It should work.

Do you expect code1 to be an int? If that’s the case, there’s 2 problems (and a couple ways to solve them) :

You need to tell read what type you want it to parse the string as. To do that, use a type annotation. Add :: int after read code .

Since you can’t concatenate an int, change code1 in your last line to (show code1) to convert it back to a String.

The problem with the above way is you’re converting from, then to a String. You could avoid any converting by keeping it as a String by skipping the read altogether:

Источник

Reading a custom data type with error Prelude.read: no parse

I am extremely new to functional programming and I have few custom data types of the following to represent a deck of cards.

Data type for Suit

Data type for Rank

Data type for Card

When I typed read «S3H5» :: Card in my stack ghci console, it shows an exception error of *** Exception: Prelude.read: no parse .

May I ask how to fix this?

I have a string of Card information, for instance, «S3HA» which represents two Cards:

What I am trying to achieve:

When I read the string of «S3HA», I want the output to be an array of

[Card Spade Three, Card Heart Ace]

Please advise! I am relatively new to Haskell functional programming!

And I do not want to modify the source code for the custom data type of Card , Suit and Rank above but utilizing those data types to create an array of [Card] . Could anyone provide ways to parse a string into a [Card] ?

1 Answer 1

As @chi says in the comments to the question, the most straightforward way to achieve your aim is to define the readList method for Card .

For lists, I think you need to redefine the readList method in your Read Card instance. If you do that then the predefined instance Read a => Read [a] will automagically call your own readList , and everything should work.

One possible definition:

However, note also that a default Show and Read instance has some advantages:

• It is usual — that is, people will know what to expect. With a custom instance, it is necessary to inspect the instance definition in order to use it correctly, while a default instance can be used immediately and effortlessly (except for a lot of typing).
• It is automatically generated — so it is unlikely there to be errors. It gives you a solid ground to stand on, for free, while a custom definition needs to be thoroughly checked if you want to ship the code in good faith.

Therefore, it may be more reasonable to put the same code into monomorphic functions, like say parseCard , parseCards , renderCard and renderCards , and have the best of both worlds.

Actually, I think custom Read instances are an obscure corner of Haskell. When I was researching for a similar problem a while ago, I could not find any guides on this subject. (Compare with the abundance of guides on, say, cellular automata or free monads.) This is maybe because people mostly live with the default derived instances until they really need to parse a lot of data, which is when advanced parsing libraries, such as parsec , come into play.

Источник

Can’t catch «Prelude.read: no parse» exception with Control.Exception.try

I trying to read some value out of a file and catch every exception that might occur (in the mindset of «Easier to ask for forgiveness than permission»). I am having trouble catching the Prelude.read: no parse exception though. To tell try that it should catch every exception I define tryAny with the explicit type SomeException which to my knowledge is the «super type» of every exception:

With tryAny I seem to be able to catch IO errors:

But the read error will not be caught:

What can I do to catch every exception?

4 Answers 4

return does not evaluate its argument, and thus doesn’t throw any exceptions. The evaluation happens outside of tryAny , when you try to print the result.

Use evaluate (possibly together with force from Control.DeepSeq , depending on your real situation) for that.

After a lot of experimenting with evaluate , force and try , following the suggestions of @Roman Cheplyaka, I’ve come up with this solution, which seems almost blazingly obvious now I see the final result:

This solution splits the process up into a function that will enforce strict evaluation and throw all exceptions and a wrapper that will catch these exceptions. force returns a pure haskell object that itself has to be evaluated first to force deep evaluation of a . From the documentation:

force x fully evaluates x, and then returns it. Note that force x only performs evaluation when the value of force x itself is demanded, so essentially it turns shallow evaluation into deep evaluation.

There are a few subtle points of this implementation that went wrong in my earlier tries:

• If you use ioA directly as input to force instead of a then you will end up with an object of type IO (IO a) , as evaluate has type b -> IO b . This immediate problem can be solved with some unwrap function of type IO(IO a) -> IO a , but then you will get a problem with the typeclass assumption of NFData a , which now needs to be NFData (IO a) . But for IO a there seems to be no instance declarations available, at least for a::(String,String) .
• Instead of using two functions you could just use tryAnyStrict = do a . The problem then is that exceptions arising from a will not be caught, for example if ioA is the result of serialized and the file that is to be read from does not exist.
• You cannot inline try.evaluateIoCompletely in your code without type information, because try needs to know which exception it is supposed to catch. This information is now supplied via the return type of tryAnyStrict which resolves the type e of try :: Exception e => IO a -> IO (Either e a) to the most general exception type SomeException .

Now after I got tryAnyStrict working I still have problems with lazy evaluation, because if a fails — where ioA is the result of read on a string read lazily from a file — (for example the file content does not have the format necessary for read ) then the file is still not completely read and thus still opened. A subsequent write on the file will fail («openFile: resource busy»). So. I might actually rewrite the whole code yet again using readMay or readMaybe as suggested by @kqr and @Roman Cheplyaka and also force a strict read of the file directly.

Источник

Hi Ian,

Thanks for looking into this. I am not sure what could be going on. I am
getting the error when building https://github.com/garetxe/haskell-gi.
More precisely, the command that fails is

/home/inaki/.cabal/bin/c2hs —cpp=/usr/bin/gcc —cppopts=-E —cppopts=-D__GLASGOW_HASKELL__=706 —cppopts=-Dlinux_BUILD_OS=1 —cppopts=-Dx86_64_BUILD_ARCH=1 —cppopts=-Dlinux_HOST_OS=1 —cppopts=-Dx86_64_HOST_ARCH=1 —cppopts=-I/usr/include/gobject-introspection-1.0 —cppopts=-I/usr/include/glib-2.0 —cppopts=-I/usr/lib64/glib-2.0/include —include=dist/build/haskell-gi/haskell-gi-tmp —cppopts=-I/usr/lib64/ghc-7.6.3/process-1.1.0.2/include —cppopts=-I/usr/lib64/ghc-7.6.3/directory-1.2.0.1/include —cppopts=-I/usr/lib64/ghc-7.6.3/unix-2.6.0.1/include —cppopts=-I/usr/lib64/ghc-7.6.3/time-1.4.0.1/include —cppopts=-I/usr/lib64/ghc-7.6.3/bytestring-0.10.0.2/include —cppopts=-I/usr/lib64/ghc-7.6.3/base-4.6.0.1/include —cppopts=-I/usr/lib64/ghc-7.6.3/include —output-dir=dist/build/haskell-gi/haskell-gi-tmp —output=GI/Internal/ArgInfo.hs ./GI/Internal/ArgInfo.chs

The file it is trying to compile is
https://github.com/garetxe/haskell-gi/blob/master/GI/Internal/ArgInfo.chs
. (I would be happy to simplify the test case if you think it is necessary,
just let me know.)

As mentioned in the first email, replacing the Read instance in the
C2HS.Gen.Monad fixes compilation for me (and the rest of the build
process works without issues). The previous instance could not work, since
the String it is trying to parse is of the form

Ident «GIBaseInfo» 436424608 (NodeInfo
(«/usr/include/gobject-introspection-1.0/gitypes.h»: line 145)
((«/usr/include/gobject-introspection-1.0/gitypes.h»: line 145),10) (Name
{nameId = 56188}))
Notice that there are no backquotes I have no clue why it is trying
to parse this string as an Ident, though, I only did a limited analysis. It
is the kind of thing that the Show instance of Ident in language-c would
produce, though.

And just to double-check: c2hs —version prints
C->Haskell Compiler, version 0.17.2 Crystal Seed, 24 Jan 2009
build platform is «x86_64-linux»
and cabal info language-c tells me that I have version 0.4.5 installed.

I am not sure why I am seeing a problem and you aren’t, but I would be
happy to try anything that you think may clarify things.

—
Reply to this email directly or view it on GitHub
#87 (comment).

I was working with using Haskell on the command line recently and it occurred to
me that it might be interesting to demo it and walk through some error handling
scenarios at the same time.

Like Perl, Python and Ruby you can invoke ghc on the command line to run
programs on the fly. Yes, Haskell makes for a good scripting language.

Let’s say we have a column of numbers that we want to add up. You may have
gotten these from a report you generated on your code repository or from
anywhere. You can use ghc to sum up the numbers.

% cat /tmp/nums
9
3
4


% cat /tmp/nums | ghc -c 'interact ((++ "n") . show . sum . map read . lines)'
16

The interact function will read from stdin and send output to stdout
without any work on our part. It just requires that your code can accept a
String and produces a String. We then break up the input into separate
lines, use read to convert the String to Nums, add them up and turn the
result back into a String.

We could just as well have put the code into a file as another way of using it
in our command line pipeline.

% cat sum.hs

main = interact ((++ "n") . show . sum . map read . lines)


% cat /tmp/nums | runhaskell sum.hs
16

Error Handling Style 1

Let’s say that our column of numbers didn’t always contain good data. Once in a
while we’d get a bad dataset that didn’t have a number in it. How would our code
react?

% cat /tmp/nums-error
9
3
not a num
4


% cat /tmp/nums-error | ghc -e 'interact ((++ "n") . show . sum . map read . lines)'
*** Exception: Prelude.read: no parse

Though we don’t have any exception handling code in place, the read function
chooses to throw an ErrorCall Exception which will halt processing and print
out a somewhat related, but kind of generic message. This might be enough for us
if all we wanted was a quick hack to sum some numbers. But if this was to grow
into some long term code that might occasionally get bad data, the error
handling would need to be a bit better because right now we’re left wondering
what failed to parse.

Error Handling Style 2

Well now we’ll just move our code into a file since it will be much easier to
work with it that way. We’ll introduce another function, catch, which will be
used to catch the ErrorCall Exception raised by read so that we can
interject a better error message. You’ll notice that we’re hiding the catch
function found in the Prelude. That’s because it only catches IOErrors as
you can see from the type signature, catch :: IO a -> (IOError -> IO a) -> IO a. What we want is the catch that’s in Control.Exception since it will
catch what we want.

-- sum.hs
import Prelude hiding ( catch )
import Control.Exception
import System.IO

main = catch (interact ((++ "n") . show . sum . map read . lines))
	(e -> hPutStrLn stderr ("couldn't sum lines: " ++ show e))


% cat /tmp/nums-error | runhaskell sum.hs
couldn't sum lines: Prelude.read: no parse

Well this worked a little better than before. We caught the exception ourselves
and added a message. But we could still use a bit more information. If we had a
large dataset and this code bombed on something in the middle of it, we’d be
left wondering what failed to parse and how could we debug this. If we want
better error reporting, we’re going to have to add more code.

Error Handling Style 3

Style 2 was a big improvement over style 1 in that we we’re explicitly catching
the exception that was thrown. The big problem though, was that we didn’t have
enough context information … we didn’t have the line from the dataset that was
bad.

main = do
  m <- hGetContents stdin
  nums <- mapM readM . lines $ m
  print (sum nums)
  `catch` (e -> hPutStrLn stderr ("couldn't sum lines: " ++ show e))

readM :: (Monad m, Read a) => String -> m a
readM s | [x] <- parse = return x
        | otherwise    = fail $ "Failed to parse "" ++ s ++ "" as a number."
  where
    parse = [x | (x,_) <- reads s]

While the code may look considerably different than before, it’s still doing the
same simple steps. The main difference is that instead of using Prelude.read,
we’ve written a custom function readM that will run in any Monad. If it is
unable to convert a String into the Num type that we expect, it will get a
pattern match failure on [x] <- parse and will instead match up against the
otherwise guard. From there we signal a fail with our more descriptive
error.

The main function has changed a bit to handle our new monadic read function.
Instead of interact we’re manually reading from stdin. But notice that our
exception handler is the same as before. It didn’t need to change. So how well
does this version work?

% cat /tmp/nums-error | runhaskell sum.hs
couldn't sum lines: user error (Failed to parse "not a num" as a number.)

Well there we go. Now we know what to search for in our dataset if we encounter
a problem.

Summary

One can use Haskell as a scripting language similar to others. Furthermore,
language features which are hard wired into other languages such as exception
handling, are actually implemented as libraries in Haskell. This ability to
extend the language via libraries both makes it very powerful for experts, but a
bit overwhelming for newbies who are confused by the myriad ways to do things.
The examples presented hopefully give some simple starting steps that people can
build on to learn more.

Code

-- sum.hs

{-# LANGUAGE PatternGuards #-}
import Prelude hiding ( catch )
import Control.Exception
import Control.Monad ( liftM )
import System.IO

main = style1

style1 = interact ((++ "n") . show . sum . map read . lines)

style2 = catch (interact ((++ "n") . show . sum . map read . lines))
         (e -> hPutStrLn stderr ("couldn't sum lines: " ++ show e))

style3 = do
  m <- hGetContents stdin
  nums <- mapM readM . lines $ m
  print (sum nums)
  `catch` (e -> hPutStrLn stderr ("couldn't sum lines: " ++ show e))


readM :: (Monad m, Read a) => String -> m a
readM s | [x] <- parse = return x
        | otherwise    = fail $ "Failed to parse "" ++ s ++ "" as a number."
  where
    parse = [x | (x,_) <- reads s]