There is function in python called eval that takes string input and evaluates it.
>>> x = 1
>>> print eval('x+1')
2
>>> print eval('12 + 32')
44
>>>
What is Haskell equivalent of eval function?
views:
404answers:
5
+1
A:
There is no eval equivalent, Haskell is a statically compiled language, same as C or C++ which does not have eval neither.
SK-logic
2010-03-18 10:52:41
It isn't always statically compiled. Take a look at `ghci`
Yacoby
2010-03-18 10:57:13
Yep, but you can't embed easily the whole ghci repl into your standalone application. Of course you can, say, use TCC from C as well, but it's not the same as 'eval' in decent dynamic languages, it's always a hack.
SK-logic
2010-03-18 11:05:00
...or indeed Hugs.
Dave Hinton
2010-03-18 11:05:38
Being statically *typed* isn't a barrier to runtime metaprogramming. It just means your 'eval' function also needs to do type checking. Which the Haskell plugins and hint packages do.Typed runtime metaprogramming.
Don Stewart
2010-03-18 17:24:47
I said 'statically compiled', not 'statically typed'.And yes, there is no eval in Haskell. It is not a dynamic language with a built-in interpreter. All the available options are invoking a detached compiler in one form or another, or implementation-specific.
SK-logic
2010-03-18 17:29:33
And, one other important point: Haskell does not preserve any metadata in a compiled binary (yes, yes, that's exactly what I meant by a static compilation, thanks for a downvote). Your mock 'eval' won't ever be able to interact with a surrounding environment. You won't pass a variable to it, won't refer to an existing datatype, etc.
SK-logic
2010-03-18 17:35:37
Being statically typed with Haskell's sophistication is actually an *advantage* in runtime metaprogramming. Using typeclasses, the evaluation library could be given very precise type information without the programmer explicitly stating them, like it's done in the Posix.Regex library.
Dario
2010-03-18 18:34:48
"you can't embed easily the whole ghci repl into your standalone application." -- is also wrong, that's what the hint library does -- export GHCi as a Haskell module. Lambdabot uses it, Yi uses it, riot has used it.Embedding the Haskell interpreter in your Haskell app is not entirely rare, and there's decent support to do so.
Don Stewart
2010-03-19 00:14:00
+3
A:
It doesn't have an inbuilt eval function. However are some packages on hackage that can do the same sort of thing. (docs). Thanks to @luqui there is also hint.
Yacoby
2010-03-18 10:54:41
hint is an easier version of the same thing: http://hackage.haskell.org/package/hint
luqui
2010-03-18 14:40:34
+9
A:
It is true that in Haskell, as in Java or C++ or similar languages, you can call out to the compiler, then dynamically load the code and execute it. However, this is generally heavy weight and almost never why people use eval() in other languages.
People tend to use eval() in a language because given that language's facilities, for certain classes of problem, it is easier to construct a string from the program input that resembles the language itself, rather than parse and evaluate the input directly.
For example, if you want to allow users to enter not just numbers in an input field, but simple arithmetic expressions, in Perl or Python it is going to be much easier to just call eval() on the input than writing a parser for the expression language you want to allow. Unfortunately, this kind of approach, almost always results in a poor user experience overall (compiler error messages weren't meant for non-programmers) and opens security holes. Solving these problems while using eval() generally involves a fair bit of code.
In Haskell, thanks to things like Parsec, it is actually very easy to write a parser and evaluator for these kinds of input problems, and considerably removes the yearning for eval.
MtnViewMark
2010-03-18 14:09:49
+5
A:
There is no 'eval' built into the language, though Template Haskell allows compile time evaluation.
For runtime 'eval' -- i.e. runtime metaprogramming -- there are a number of packages on Hackage that essentially import GHC or GHCi, including the old hs-plugins package, and the hint package.
Don Stewart
2010-03-18 17:23:54
This has nothing in common with a Python-style eval. You won't have an access to your code metadata. What you're talking about is just constructing Haskell code from within Haskell, it remains detached. The only way to have a proper eval for a statically compiled language (especially if there's a separate compilation) is to preserve all the metadata (types, name tables, etc.) and link the compiler or interpreter into any binary.
SK-logic
2010-03-18 17:40:53
Btw., see the first example in the question. You can't ever do this in Haskell. It's not possible to pass the information about a local binding 'x' into your 'eval' function.
SK-logic
2010-03-18 17:46:20
See the hs-plugins paper for how to preserve the metadata -- it is done via Haskell's compile-time reflection capability (TH), combined with the Data.Dynamic dynamic type mechanism for splice points.http://www.cse.unsw.edu.au/~dons/hs-plugins/Reflection + runtime code generation + dynamics for splice points gives you a full multistage metaprogramming model.
Don Stewart
2010-03-18 17:58:51
SK, that is simply not true. What Don says, and also take a look at the hint package, specifically at function 'interpret' which brings an evaluated value into the current environment. As for bringing a local 'x' into scope, simply eval a function and then apply it to x.
Martijn
2010-03-19 08:48:38
While it is true, that there are ways to achieve the same ends, and indeed they are safer and more controlled ways, @SK-logic does have a valid point: eval() in Python offers program source authored at run-time direct, full access to the environment containing the eval() *even without the programmer intending it*. In Haskell you'd have to be very explicit about what you wanted to provide the run-time code access to, *which is a good thing*, but different than eval() nonetheless.
MtnViewMark
2010-03-19 15:06:29