Не удалось найти тип Integer в Haskell

Question

В упражнении, которое я делаю для курса функционального программирования, меня просят найти самый низкий x, для которого x mod a = b, получив серию пар (a, b),

В случае, когда мне дают три пары (кортежи), я использую следующий код:

solveModularEq :: [(Integer,Integer)] -> Integer
solveModularEq [(a),(b),(c)] = lowestModThree(fst(a) snd(a) fst(b) snd(b) fst(c) snd(c) 1)

lowestModThree :: Integer -> Integer -> Integer -> Integer -> Integer -> 
Integer -> Integer -> Integer 
lowestModThree a b c aa bb cc k
  | k `mod` a == aa && k `mod` b == bb && k `mod` c == cc = k
  | k > (aa * bb * cc) = aa * bb * cc
  | otherwise = lowestModThree a b c aa bb cc (k+1)

В случае, если такого x не существует, вернуть произведение модулей.

Ошибки, которые я получаю, странные, потому что не похоже, что я не соответствую никаким типам.

modEq.hs:3:32:
   Couldn't match expected type ‘Integer’
              with actual type ‘Integer
                                 -> Integer -> Integer -> Integer -> Integer -> Integer -> Integer’
   Probable cause: ‘lowestModThree’ is applied to too few arguments
  In the expression:
     lowestModThree (fst (a) snd (a) fst (b) snd (b) fst (c) snd (c) 1)
   In an equation for ‘solveModularEq’:
      solveModularEq [(a), (b), (c)]
         = lowestModThree
             (fst (a) snd (a) fst (b) snd (b) fst (c) snd (c) 1)

modEq.hs:3:51:
  Couldn't match type ‘Integer’
                  with ‘((a0, b0) -> b0)
                       -> (Integer, Integer)
                        -> ((a1, b1) -> a1)
                        -> (Integer, Integer)
                        -> ((a2, b2) -> b2)
                        -> (Integer, Integer)
                        -> ((a3, b3) -> a3)
                        -> (Integer, Integer)
                        -> ((a4, b4) -> b4)
                        -> (Integer, Integer)
                        -> Integer
                        -> Integer’
   Expected type: (((a0, b0) -> b0)
                   -> (Integer, Integer)
                   -> ((a1, b1) -> a1)
                   -> (Integer, Integer)
                   -> ((a2, b2) -> b2)
                   -> (Integer, Integer)
                   -> ((a3, b3) -> a3)
                   -> (Integer, Integer)
                   -> ((a4, b4) -> b4)
                   -> (Integer, Integer)
                   -> Integer
                   -> Integer,
                   Integer)
     Actual type: (Integer, Integer)
   In the first argument of ‘fst’, namely ‘(a)’
   In the first argument of ‘lowestModThree’, namely
     ‘(fst (a) snd (a) fst (b) snd (b) fst (c) snd (c) 1)’

То же самое происходит в моей реализации рекурсивной реализации теста на простоту.

isPrimeRec :: Int -> Bool
isPrimeRec n = isPrimeRec'(isqrt(n) n)

isPrimeRec' :: Int -> Int -> Bool
isPrimeRec' divisor n
  | mod n divisor == 0 = isPrimeRec' (divisor-1) n
  | mod n divisor /= 0 = False
  | divisor < 2 = True

Ошибка для этого

palPrimes.hs:10:16:
    Couldn't match expected type ‘Bool’ with actual type ‘Int -> Bool’
    Probable cause: ‘isPrimeRec'’ is applied to too few arguments
    In the expression: isPrimeRec' (isqrt (n) n)
    In an equation for ‘isPrimeRec’:
        isPrimeRec n = isPrimeRec' (isqrt (n) n)

palPrimes.hs:10:28:
    Couldn't match expected type ‘Int -> Int’ with actual type ‘Int’
    The function ‘isqrt’ is applied to two arguments,
    but its type ‘Int -> Int’ has only one
    In the first argument of ‘isPrimeRec'’, namely ‘(isqrt (n) n)’
    In the expression: isPrimeRec' (isqrt (n) n)

Answer 1

Синтаксис для применения функции f спорить x является f xне f(x), Приложения ассоциируются слева, поэтому f x y средства (f x) y - то есть применять f в xи применить полученную функцию к y, Если x само по себе является сложным выражением с приложениями функций, вы можете использовать дополнительные скобки для устранения неоднозначности; так, например:

• a b c d применяет функцию a к аргументам b, c, а также d
• a (b c) d применяет функцию a к аргументам b c а также d
• a b (c d) применяет функцию a к аргументам b а также c d
• a (b c d) применяет функцию a одному аргументу, b c d