2

I'm pretty new in Haskell programming. I want to call some functions and save the result in a variable but I don't know how. I read couple of chapters about haskell function in two different book but still don't understand how to do it.

import Data.Map (Map)
import qualified Data.Map as M hiding (Map)

newtype GenEnv elt = Env (Map Id elt)

newEnv :: GenEnv elt                             -- initialise
newEnv = Env M.empty
newtype GenEnv elt = Env (Map Id elt)

newEnv :: GenEnv elt                             -- initialise
newEnv = Env M.empty

getEnv :: GenEnv elt -> Id -> Maybe elt          -- G(x) (key function)
getEnv (Env env) var = M.lookup var env

union  :: GenEnv elt -> (Id,elt) -> GenEnv elt    -- G[x:v]
union  (Env env) (key,elt) = Env (M.insert key elt env)

-- foldr is faster than addToFM_list!
unionL :: GenEnv elt -> [(Id,elt)] -> GenEnv elt -- list union
unionL (Env env) pairs  = Env $ foldr (\(k,e) g -> M.insert k e g) env pairs

What I'm asking here is NOT for somebody to do my work, asking how to call the functions because I don't understand their signature.

Improve this question
3
  • 3
    Looks like GenEnv and newEnv are declared twise. Is it a typo? Commented Sep 4, 2011 at 14:53
  • 1
    fans I think people need a bit more help figuring out what you are ultimately aiming at. I wonder if you see all these functions like update filter insert etc. that take you from one Map to another, and wonder, but how do I build up a Map to begin with? How do I get to the point of using these functions? If that's the problem, then there are a number of answers, but the simple-minded answer is by using fromList fromAscList etc. You start with a list, e.g. of key value pairs, use fromList, engage in fancy Data.Map manipulations, then return to list-land with toList and co. Commented Sep 4, 2011 at 17:39
  • my question basically is, if I want to build a new map insert some data in it and then retrieve them. how to do that using the above functions. I came from java background and this is my first time to be exposed to functional programming. Commented Sep 5, 2011 at 8:49

4 Answers 4

Reset to default
2

As others have mentioned, "variable" is perhaps not the right term. And in the same vein, "calling" a function is perhaps not the right term either. It is helpful, in my opinion, to think about this in terms of mathematical functions:

f(x) = x^2

given the above function, you don't "call" it with a value so much as give a name to the result of evaluating that function at a particular argument:

y = f(2)

It's the same in Haskell. Somewhere in your code you need to use the result of evaluating a function at a particular value. To do that, you can just use the application of that function to that value wherever you need it, or you can bind it to a name in a let binding or a where clause.

So, to provide a simple example in Haskell, you can do something like this:

f :: Int -> Int
f x = x^2

y :: Int
y = f 2

g :: Int -> Int
g x = let y = f 3
      in y + 1

h :: Int -> Int
h x = y + 1
        where y = f 3

Here I have declared a function called f which takes a single Int value and returns a new Int value, the square of the argument. Then I have declared an Int value named y to be the result of applying f to 2. The value y is not a variable, but rather a binding. It will always be 4.

Then I have declared two other functions, g and h which are equivalent, showing local bindings of the results of applying f.

In your example, the types are perhaps complicating things a little bit. Env is a constructor used to construct a value of the Genenv type. So, to create a value that is a Genenv type, you apply Env to an appropriate argument. This is what newEnv is doing.

Hopefully that's enough to get you started.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

What I'm aiming to is to create new environment, map, insert values in it and them from time to time check if some key are in it or not. however I can not make sense of the syntax of how to interact with the functions above.
first thanks for replying, I wanted to ask is (Id,elt) a tuble?
1

Since I pretty much suck at explaining these things, I'd recomment reading this chapter

http://book.realworldhaskell.org/read/types-and-functions.html

should cover everything you need to know to be able to call those functions.

In general in Haskell we apply a function to some arguments and bind the results to some value.

Improve this answer

Comments

0

Haskell doesn't have variables, first of all. Generally we talk of binding an expression to an identifier, creating a thunk.

It has the form of

let val = unionEl g l
in --expression using val
Improve this answer

3 Comments

To quote myself: "The Haskell 98 Report uses the term 'variable' all over the place. It's important to note that this doesn't mean what you might expect, but I don't think being more persnickety than the standard documentation is necessarily helpful."
Actually, Haskell's variables are just like variables in mathematics.
I'm meaning variables in the typical sense.
0

In Haskell, function application is done through juxtaposition, but you can use parentheses first to get the feel for it, just don't use commas to separate parameters like you may be used to in other languages.

For instance, assuming Id is just a type synonym for Int, then the following would be an example GenEnv.

example :: GenEnv Char 
example = union newEnv (1, 'a')

which is the same as 

example :: GenEnv Char 
example = union(newEnv (1, 'a'))

Say you have a list of the alphabet, associated with an integer value, called alphabetKeys, you can use the handy little tool you defined to turn that into a GenEnv pretty easily, just by 

example :: GenEnv Char
example = union newEnv alphabetKeys

again, 

 example :: GenEnv Char 
 example = union(newEnv alphabetKeys)

would work just as well.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.