Create a list from data and keys - list

Question

I have a question about Haskell. I want to know how I can create a list of data from two lists, one with data, an other with some key values. I'll explain it with an example:
Given two lists: [('a', "red"), ('b', "blue"), ('c', "green")] and [('a','b'), ('b', 'c'), ('c','a')]. Now I want to change the values of the second list with their colors given in the first list. So the function should return [("red","blue"), ("blue","green"), ("blue","red")].
I was thinking about list comprehension, but I'm very new to Haskell and I have no idea how I should do that. Or is there an easier way to do this?
This is probably a dumb question, but if someone can give me an example, I might get used to the think process of Haskell a bit more.

Answer 1

Another way would be to use Map
import Data.Maybe (mapMaybe)
import Data.Map (lookup
,fromList)
import Prelude hiding (lookup)
main :: IO ()
main = do
let a = [('a', "red"), ('b', "blue"), ('c', "green")]
b = [('a','b'), ('b', 'c'), ('c','a')]
table = fromList a
print $ mapMaybe (maybePair . (\(x,y) -> (x `lookup` table,
y `lookup` table ))) b
maybePair :: (Maybe a, Maybe b) -> Maybe (a,b)
maybePair (Just x,Just y) = Just (x, y)
maybePair _ = Nothing
Edit:
with the help of arrows the last anonymous function can be condensed to
import Control.Arrow ((***))
[…]
main :: IO ()
main = do
let a = [('a', "red"), ('b', "blue"), ('c', "green")]
b = [('a','b'), ('b', 'c'), ('c','a')]
table = fromList a
f x = x `lookup` table
print $ mapMaybe (maybePair . (f *** f)) b
[…]

Answer 2

-- second element from first (head) dropping tuples with bad key
color :: Eq a => a -> [(a, b)] -> b
color c = snd.head.dropWhile ((/=c).fst)
recolor a b = map (\(x, y) -> (color x a, color y a)) b
running
Prelude> recolor [('a', "red"), ('b', "blue"), ('c', "green")] [('a','b'), ('b', 'c'), ('c','a')]
[("red","blue"),("blue","green"),("green","red")]
If you consider an element of the second list cannot be found in the first list. You can write
color :: Eq b => b -> [(b, a)] -> Maybe a
color c = fmap snd.listToMaybe.dropWhile ((/=c).fst)
then
Prelude> recolor [('a',"red"),('b',"blue"),('c',"green")] [('a','h'),('u','c'),('c','a')]
[(Just "red",Nothing),(Nothing,Just "green"),(Just "green",Just "red")]
(you need import Data.Maybe (listToMaybe))

Answer 3

Another solution without need of importing any library but using tail recursion:
keyColor = [('a', "red"), ('b', "blue"), ('c', "green")]
keys = [('a','b'), ('b', 'c'), ('c','a')]
colors [] _ = [] -- no keys returns the empty list
colors _ [] = [] -- no colors returns the empty list
colors xs ys = colors_helper (xs, ys, []) -- tail recursion
colors_helper ([], _, acc) = acc
colors_helper (((k1, k2):xs), ys, acc) =
colors_helper (xs, ys, acc ++ [(color (k1, ys), color (k2, ys))])
where
-- converts value to color
color (val, ys) = snd $ head $ filter ( \(k, v) -> k == val ) ys
test:
> colors keys keyColor
> [("red","blue"),("blue","green"),("green","red")]
> colors keys []
> []
> colors [] keyColor
> []