欧拉50计划:算法非常慢，无法理解原因

我正在使用Project Euler学习Haskell。我是Haskell的新手，在想出一个不需要花费大量时间的算法时遇到了很多麻烦。我估计这个项目需要140亿年才能找到解决方案。

问题:

小于一百万的哪个素数可以写成最数的和连续质数?

这是我的来源。我漏掉了isPrime。我把它贴出来是因为解决这个问题的效率太低了。我认为问题在于切片链和primeChains调用，但我不确定它是什么。我以前用c++解决了这个问题。但无论出于何种原因，在Haskell中高效的解决方案似乎超出了我的能力范围。

编辑:我已经包括了isPrime。

import System.Environment (getArgs)
import Data.List (nub,maximumBy)
import Data.Ord (comparing)
isPrime :: Integer -> Bool
isPrime 1 = False
isPrime 2 = True
isPrime x
        | any (== 0) (fmap (x `mod`) [2..x-1]) = False
        | otherwise = True
primeChain :: Integer -> [Integer]
primeChain x = [ n | n <- 1 : 2 : [3,5..x-1], isPrime n ]
slice :: [a] -> [Int] -> [a]
slice xs args = take (to - from + 1) (drop from xs)
    where from = head args
          to = last args
subsequencesOfSize :: Int -> [a] -> [[a]]
subsequencesOfSize n xs = let l = length xs
                          in if n>l then [] else subsequencesBySize xs !! (l-n)
    where
        subsequencesBySize [] = [[[]]]
        subsequencesBySize (x:xs) = let next = subsequencesBySize xs
                                    in zipWith (++) ([]:next) (map (map (x:)) next ++ [[]])
slicedChains :: Int -> [Integer] -> [[Integer]]
slicedChains len xs = nub [x | x <- fmap (xs `slice`) subseqs, length x > 1]
    where subseqs = [x | x <- (subsequencesOfSize 2 [1..len]), (last x) > (head x)]
primeSums :: Integer -> [[Integer]]
primeSums x = filter (ns -> sum ns == x) chain
    where xs = primeChain x
          len = length xs
          chain = slicedChains len xs
compLength :: [[a]] -> [a]
compLength xs = maximumBy (comparing length) xs
cleanSums :: [Integer] -> [[Integer]]
cleanSums xs = fmap (compLength) filtered
    where filtered = filter (not . null) (fmap primeSums xs)
main :: IO()
main = do
    args <- getArgs
    let arg = read (head args) :: Integer
    let xs = primeChain arg
    print $ maximumBy (comparing length) $ cleanSums xs