Может быть, вы не применили достаточно аргументов к функции?

Прежде всего, (:) предназначен только для добавления элементов в начало списка (или сопоставления шаблона с ними), поэтому вам нужно заменить

f : compose fs x

с

f (compose fs x)

Далее вы должны использовать выражение типа Bool или совпадение с образцом в стороже:

| fs == []  = -- this line is still wrong, see below
| otherwise = f (compose f xs)

Однако для функций нет экземпляра Eq. Эквивалентность двух функций неразрешима (в общем случае), поэтому используйте null :: [a] -> Bool вместо (==) :: Eq a => [a] -> [a] -> Bool:

compose :: [(Int -> Int)] -> Int -> Int
compose [] x = x
compose (f:fs) x  
  | null fs   = f x
  | otherwise = f (compose fs x)

Поскольку compose [] x совпадает с x, вы даже можете убрать галочку:

compose :: [(Int -> Int)] -> Int -> Int
compose []     x = x
compose (f:fs) x = f (compose fs x)

Упражнения

• Расширьте compose [(+1), (+2)] 1 (замените его определением), не избавляясь от промежуточных терминов. Вы замечаете закономерность?
• Этот паттерн напоминает вам библиотечную функцию?
• Попробуйте использовать эту библиотечную функцию, чтобы написать compose.

|f  : (compose fs x)
    ^

Я думаю, ваша проблема в том, что этого двоеточия здесь быть не должно. : в Haskell — это конструктор списка, поэтому компилятор сообщает вам, что вы пытаетесь вернуть [Int -> Int]. Если бы его там не было, просто применялась бы f, и вы бы возвращали Int.

Вы должны многократно применять функции к результату, а пустой список функций следует рассматривать как идентификатор.

Prelude> let comp :: [(Int->Int)] -> Int -> Int
Prelude|     comp [] x = x
Prelude|     comp (f:fs) x = comp fs (f x)
Prelude|
Prelude> comp [(^2),(+1)] 3
10

Я неправильно прочитал задачу, выше применяются функции слева направо. Если вы сочиняете слева направо (сначала будет применена крайняя правая функция), это должно быть так (теперь без точек).

Prelude> let comp2 :: [(Int->Int)] -> Int -> Int
Prelude|     comp2 [] = id
Prelude|     comp2 (f:fs) = f . comp2 fs
Prelude|
Prelude> comp2 [(^2),(+1)] 3
16
Prelude> comp2 [negate,(+2)] 3
-5

Поскольку прошло уже несколько часов, позвольте мне дать пару советов о том, как написать это в виде сгиба. Поскольку есть два направления, в которых вы можете составлять функции, и я не получаю баллов за правильное выполнение, я просто покажу оба.

Во-первых, некоторый шаблон:

import Data.Monoid (Dual (..))
import Control.Category (Category (..))
import Data.Foldable (Foldable (foldMap))
import Prelude hiding (id, (.))

Далее тип, объясняющий, что моноид — это категория с ровно одним объектом:

newtype Cat c a = Cat { getCat :: c a a }

instance Category c => Monoid (Cat c a) where
  mempty = Cat id
  mappend (Cat f) (Cat g) = Cat (f . g)

Наконец, функции, которые вы ищете, обобщены от -> до произвольного Category:

compose1 :: (Foldable f, Category c) => f (c a a) -> c a a
compose1 = getCat . foldMap Cat

compose2 :: (Foldable f, Category c) => f (c a a) -> c a a
compose2 = getCat . getDual . foldMap (Dual . Cat)

Упражнение для читателя: напишите эквивалентные функции, заменив Category на Semigroupoid и Foldable на Foldable1.

Еще одно упражнение для читателя: напишите экземпляр Monoid (Cat c a), используя Data.Coerce.coerce и/или #. и .# из Data.Profunctor.Unsafe, чтобы избежать ложного выделения замыкания.

P.S. Тип Cat объясняет только половину истории. Вот остальное:

newtype Mon m a b = Mon m

instance Monoid m => Category (Mon m) where
  id = Mon mempty
  Mon m . Mon n = Mon (m `mappend` n)

Возможно, было бы более точным использовать

data Mon m a b where
  Mon :: m -> Mon m a a

Но это было бы менее эффективно, не добавляя реальной ценности.