Getting element out of IO in Haskell

Question

I am working through the amazing Write Yourself a Scheme in 48 Hours and have completed the core tasks and wanted to extend it but ran into problem. What I wanted to do is make `eval` function available to runtime, but have issue storing it into the global environment. The runtime environment is of type: ``` type Env = IORef [(String, IORef LispVal)] ``` The Haskell `eval` implementation is of type: ``` eval :: Env -> LispVal -> IOThrowsError LispVal ``` The global environment is a mapping of type: ``` primitiveBindings :: IO Env ``` as it contain functions performing IO mixed with pure functions. My attempt was to set the runtime `eval` to the host `eval` partially applied with global environment like this: ``` baseFun :: [(String, [LispVal] -> IOThrowsError LispVal)] baseFun = [("eval", unaryOp (eval (liftIO $ readIORef primitiveBindings)))] ``` Where `unaryOp` is: ``` unaryOp :: (LispVal -> ThrowsError LispVal) -> [LispVal] -> ThrowsError LispVal unaryOp f [v] = f v ``` I wanted to…

Accepted Answer

As far as I can tell, `primitiveBindings` is not a global environment, but rather an action that, when performed, generates a fresh mapping with the primitive bindings already set up. Perhaps a better name for it would have been `createPrimitiveBindings`. There is no way to have proper globals in Haskell without `unsafePerformIO` hacks.

Therefore, the way you're trying to add `eval` would make it evaluate everything in a new environment, since you're re-running the `primitiveBindings` action. We can easily take care of the type errors, if that is indeed what you intended:

```
baseFun :: [(String, [LispVal] -> IOThrowsError LispVal)]
baseFun = [("eval", evalInNewEnv)]
    where evalInNewEnv args = do
              env <- liftIO primitiveBindings
              unaryOp (eval env) args
```

As you see, there is no need for any `readIORef` here, since `eval` already expects `Env` which just a type synonym for an `IORef`.

However, it sounds to me like you'd like `eval` to work in a "global" environment, in which case, you would need to have this environment passed to you somehow, since as I mentioned, there are no globals. For example, we can define something like this which would create a new environment with `eval` in it.

```
primitiveBindingsWithEval :: IO Env
primitiveBindingsWithEval = do
    env <- primitiveBindings    
    bindVars env [("eval", unaryOp (eval env))]
```

You can then replace existing uses of `primitiveBindings` with `primitiveBindingsWithEval` when you want a fresh environment with `eval` in it.

Getting element out of IO in Haskell

Solution

Problem