Computing all Tic-Tac-Toe moves
First of all, you can use a where binding to clear this up:

moves :: Player -&gt; Board -&gt; [Board]
moves p ((a,b,c),(d,e,f), (g,h,i)) = (moves' a ((s,b,c), (d,e,f), (g,h,i))) ++
                                     (moves' b ((a,s,c), (d,e,f), (g,h,i))) ++
                                     (moves' c ((a,b,s), (d,e,f), (g,h,i))) ++
                                     (moves' d ((a,b,c), (s,e,f), (g,h,i))) ++
                                     (moves' e ((a,b,c), (d,s,f), (g,h,i))) ++
                                     (moves' f ((a,b,c), (d,e,s), (g,h,i))) ++
                                     (moves' g ((a,b,c), (d,e,f), (s,h,i))) ++
                                     (moves' h ((a,b,c), (d,e,f), (g,s,i))) ++
                                     (moves' i ((a,b,c), (d,e,f), (g,h,s)))
    where
        s = symbol p


Next, I would recommend changing your Board type to use a flat list instead of nested tuples, it's a lot easier to work with:

type Board = [Field]


For whatever your Field type is (for future reference please include all relevant definitions in your questions on SO, this goes for any language).  Now you can write this a bit differently:

moves :: Player -&gt; Board -&gt; [Board]
moves p [a, b, c, d, e, f, g, h, i] = moves' a [s, b, c, d, e, f, g, h, i] ++
                                      moves' b [a, s, c, d, e, f, g, h, i] ++
                                      moves' c [a, b, s, d, e, f, g, h, i] ++
                                      moves' d [a, b, c, s, e, f, g, h, i] ++
                                      moves' e [a, b, c, d, s, f, g, h, i] ++
                                      moves' f [a, b, c, d, e, s, g, h, i] ++
                                      moves' g [a, b, c, d, e, f, s, h, i] ++
                                      moves' h [a, b, c, d, e, f, g, s, i] ++
                                      moves' i [a, b, c, d, e, f, g, h, s]
    where
        s = symbol p


Now I recognize a zipWith here between the first and second arguments to moves', although we'll need a concat after the zipWith is done:

moves :: Player -&gt; Board -&gt; [Board]
moves p board@[a, b, c, d, e, f, g, h, i]
    = concat
    $ zipWith moves'
        board
        [[s, b, c, d, e, f, g, h, i],
         [a, s, c, d, e, f, g, h, i],
         [a, b, s, d, e, f, g, h, i],
         [a, b, c, s, e, f, g, h, i],
         [a, b, c, d, s, f, g, h, i],
         [a, b, c, d, e, s, g, h, i],
         [a, b, c, d, e, f, s, h, i],
         [a, b, c, d, e, f, g, s, i],
         [a, b, c, d, e, f, g, h, s]]
    where
        s = symbol p


Now, this still leaves the big block of different boards.  There is definitely a pattern here.  If you have a replace function with the type replace :: Int -&gt; a -&gt; [a] -&gt; [a] (I'll leave this as an exercise to the reader) then you could write this as

[replace 0 s board,
 replace 1 s board,
 replace 2 s board,
 replace 3 s board,
 replace 4 s board,
 replace 5 s board,
 replace 6 s board,
 replace 7 s board,
 replace 8 s board]


Or more simply

map (\i -&gt; replace i s board) [0..8]


So your entire function becomes

moves p board
    = concat $ zipWith moves' board
    $ map (\i -&gt; replace i s board) [0..8]
    where
        s = symbol p
        replace i a xs = undefined
        moves' B m = [m]
        moves' _ _ = []