Cellular Automata on Torus

*Main Data.Bits> printRuleLines 20 90 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
                    #                    
                   # #                   
                  #   #                  
                 # # # #                 
                #       #                
               # #     # #               
              #   #   #   #              
             # # # # # # # #             
            #               #            
           # #             # #           
          #   #           #   #          
         # # # #         # # # #         
        #       #       #       #        
       # #     # #     # #     # #       
      #   #   #   #   #   #   #   #      
     # # # # # # # # # # # # # # # #     
    #                               #    
   # #                             # #   
  #   #                           #   #  
 # # # #                         # # # # 




import Data.Bits

threes :: [a] -> [(a,a,a)]
threes (x:y:z:xs) = (x,y,z) : threes (y:z:xs)
threes (x:y:[]) = []

firstThree (x:y:xs) = (last xs,x,y)
lastThree (x:xs) = last $ threes (xs ++ [x])

neighbourStates :: [a] -> [(a,a,a)]
neighbourStates xs = firstThree xs : threes xs ++ [lastThree xs]

transition :: Int -> (Int,Int,Int) -> Int
transition rule (l,c,r) = if (2^(l*4 + c*2 + r) .&. rule) == 0
                          then 0
                          else 1

step rule xs = map (transition rule) $ neighbourStates xs

showState (1:xs) = '#' : showState xs
showState (0:xs) = ' ' : showState xs
showState [] = ""

printRuleLines n r xs = mapM_ putStrLn $ map showState $ take n $ iterate (step r) xs