How do you call functions dynamically with Haskell

Question

I'm looking to call functions dynamically based on the contents found in an association list.

Here is an example in semi-pseudo-code. listOfFunctions would be passed to callFunctions.

listOfFunctions = [('function one', 'value one')
                   , ('function two', 'value two')
                   , ('function three', 'value three')]

callFunctions x = loop through functions
                  if entry found 
                  then call function with value
                  else do nothing

The crux of the question is not looping through the list, rather, it's how to call a function once I have it's name?

Consider this use case for further clarification. You open the command prompt and are presented with the following menu.

1: Write new vHost file

2: Exit

You write the new vHost file and are not presented with a new menu

1: Enter new directive

2: Write file

3: Exit

You enter some new directives for the vHost and are now ready to write the file.

The program isn't going to blindly write each and every directive it can, rather, it will only write the ones that you supplied. This is where the association list comes in. Writing a giant if/then/else or case statement is madness. It would be much more elegant to loop through the list, look for which directives were added and call the functions to write them accordingly.

Hence, loop, find a function name, call said function with supplied value.

Thanks to anyone who can help out with this.

Edit:

Here is the solution that I've come up with (constructive critiques are always welcome).

I exported the functions which write the directives in an association list as every answer provided said that just including the function is the way to go.

funcMap = [("writeServerName", writeServerName)
           ,("writeServeralias", writeServerAlias)
           ,("writeDocRoot", writeDocRoot)
           ,("writeLogLevel", writeErrorLog)
           ,("writeErrorPipe", writeErrorPipe)
           ,("writeVhostOpen", writeVhostOpen)]

In the file which actually writes the hosts, that file is imported.

I have an association list called hostInfo to simulate some dummy value that would be gathered from an end-user and a function called runFunction which uses the technique supplied by edalorzo to filter through both the lists. By matching on the keys of both lists I ensure that the right function is called with the right value.

import Vhost.Directive

hostInfo =     [("writeVhostOpen", "localhost:80")
                ,("writeServerName", "norics.com")] 

runFunctions = [f val | (mapKey, f) <- funcMap, (key, val) <- hostInfo, mapKey == key]

Answer 1

You can simply include the function in the list directly; functions are values, so you can reference them by name in a list. Once you've got them out of the list, applying them is just as simple as func value. There's no need to involve their names at all.