Пытаюсь скомпилировать такой код:

{-# LANGUAGE ExistentialQuantification #-}
module Ex where

  import Maybe

  class (EX a) where
    cool :: a -> Bool

  process :: forall a b. (EX a, EX b) => a -> (a -> Maybe b) -> Maybe b
  process x processor = processor x

  myProcessor :: forall a b. (EX a, EX b) => a -> Maybe b
  myProcessor x = Nothing

  doStuff :: forall a. (EX a) => a -> Bool
  doStuff x = let newX = process x myProcessor
              in False

Никак не пойму, почему появляется ошибка

exist.hs:16:25:
    Ambiguous type variable `b' in the constraint:
      `EX b' arising from a use of `process' at exist.hs:16:25-45
    Probable fix: add a type signature that fixes these type variable(s)

Объясните, пожалуйста, что не так, и как это можно исправить (с примером, если можно ).

Здравствуйте, awk, Вы писали:

awk>Объясните, пожалуйста, что не так, и как это можно исправить (с примером, если можно ).

Ну не может он вывести какой тип будет у newX! Исправить можно двумя способами:
1) добавить {-# LANGUAGE NoMonomorphismRestriction #-}
2) переписать по-нормальному

Здравствуйте, awk, Вы писали:

Предыдущее сообщение написал я.

Здравствуйте, haskell_beginner, Вы писали:

А>Ну не может он вывести какой тип будет у newX! Исправить можно двумя способами:
А>1) добавить {-# LANGUAGE NoMonomorphismRestriction #-}

Спасибо, сработало.
Я правильно понимаю, что сейчас ему недостаточно, что у newX будет "какой-то тип, принадлежащий к классу EX"?

А>2) переписать по-нормальному

А как? Я пытаюсь получить поведение, аналогичное интерфейсам. Конкретная задача — сделать работу с символьными выражениями
начал примерно с этого:

{- Symbolic expression -}
class (EX a) where
  {- Enumerate/edit subexpressions -}
  visit :: forall b c d. (EX b, EX c, EX d) => a -> (b -> Maybe c) -> d

{- Binary op type -}
data T2 = T2_ADD | T2_SUB

{- Binary op -}
data EX2 = forall a b. (EX a, EX b) => EX2 a b T2
instance EX EX2 where
  visit (EX2 left right t) visitor = let newLeft = visitor left {- тут вылезает такая же ошибка -}
                                     ...

Здравствуйте, awk, Вы писали:

awk>Здравствуйте, haskell_beginner, Вы писали:

А>>Ну не может он вывести какой тип будет у newX! Исправить можно двумя способами:
А>>1) добавить {-# LANGUAGE NoMonomorphismRestriction #-}

awk>Спасибо, сработало.
awk>Я правильно понимаю, что сейчас ему недостаточно, что у newX будет "какой-то тип, принадлежащий к классу EX"?

А>>2) переписать по-нормальному

awk>А как? Я пытаюсь получить поведение, аналогичное интерфейсам. Конкретная задача — сделать работу с символьными выражениями
awk>начал примерно с этого:

awk>

awk>{- Symbolic expression -}
awk>class (EX a) where
awk>  {- Enumerate/edit subexpressions -}
awk>  visit :: forall b c d. (EX b, EX c, EX d) => a -> (b -> Maybe c) -> d

awk>{- Binary op type -}
awk>data T2 = T2_ADD | T2_SUB

awk>{- Binary op -}
awk>data EX2 = forall a b. (EX a, EX b) => EX2 a b T2
awk>instance EX EX2 where
awk>  visit (EX2 left right t) visitor = let newLeft = visitor left {- тут вылезает такая же ошибка -}
awk>                                     ...

awk>

Забыл написать — не хочется заранее ограничивать виды выражений, т.е. делать что-то вроде

data EX = EXI Int | EX1 EX T1 | EX2 EX EX T2

Здравствуйте, awk, Вы писали:

awk>Забыл написать — не хочется заранее ограничивать виды выражений, т.е. делать что-то вроде

Чего ты хочешь в результате? Что на входе, что на выходе?
Аналог на интерфейсах дай, плз, может так будет проще понять. Пока же вижу, что ты зарываешься в динамику — это не haskell-way.