Haskell при создании новых данных

Question

{- P A R T 2 : Implementation of a parser for Łukasiewicz expressions 
--TODO Define the type LExpTree, using the constructors L, V, N, Q, S, K, A, O, E, I 
L for Lukasiewicz literals (i.e. C, I or U) 
V for Variables (string) 
N for a node representing the prefix neg 
Q for a node representing the prefix pos 
S for a node representing the prefix cer 
K for a node representing the prefix unk 
A for a node representing the infix And 
O for a node representing the infix Or 
E for a node representing the infix Equivalence 
M for a node representing the infix Implication 
It will be convenient to have the new type derive from the classes Show and Eq 
-} 
data LExpTree a = L a 
       | V [Char] 
       | N (LExpTree a) 
       | Q (LExpTree a) 
       | S (LExpTree a) 
       | K (LExpTree a) 
       | A (LExpTree a) (LExpTree a) 
       | O (LExpTree a) (LExpTree a) 
       | E (LExpTree a) (LExpTree a) 
       | M (LExpTree a) (LExpTree a) 
       deriving (Show, Eq) 

Это мой проект Haskell. Я пробовал это в течение 4 дней. Я просто хочу проверить, верны ли мои данные LExpTree?

Я не думаю, хотя ..

После этого я должен создать серию анализаторов в грамматике

Это 3 из них.

{- 
lukExp :: lukOpd ('<->' lukExp | '-->' lukExp| e) 
lukVar :: lowercase (Alphanumeric)* 
lukLit :: C | I | U 
-} 
lukExp :: Parser LExpTree 
lukExp = do o <- lukOpd 
      (do { symbol "<->"; 
        e <- lukExp; 
        return (E (o <-> e)); } 
      +++ do { symbol "-->"; 
         e <- lukExp; 
         return (E (o --> e)); } 
      +++ return (E o)) 

lukVar :: Parser LExpTree 
lukVar = ident 

lukLit :: Parser LExpTree 
lukLit = do { symbol "C"; 
       return (L C); } 
     +++ do { symbol "I"; 
        return (L I); } 
     +++ do { symbol "U"; 
        return (L U); } 

И я получаю эти ошибки.

proj.hs:131:18: 
    Expecting one more argument to `LExpTree' 
    The first argument of `Parser' should have kind `*', 
     but `LExpTree' has kind `* -> *' 
    In the type signature for `lukExp': lukExp :: Parser LExpTree 

proj.hs:184:18: 
    Expecting one more argument to `LExpTree' 
    The first argument of `Parser' should have kind `*', 
     but `LExpTree' has kind `* -> *' 
    In the type signature for `lukVar': lukVar :: Parser LExpTree 

proj.hs:187:18: 
    Expecting one more argument to `LExpTree' 
    The first argument of `Parser' should have kind `*', 
     but `LExpTree' has kind `* -> *' 
    In the type signature for `lukLit': lukLit :: Parser LExpTree 
Failed, modules loaded: Parser. 

Проект заключается в создании Лукасевич выражения C наверняка, U для неопределенной, и я для нельзя.

И у меня уже есть Parser.hs, и он имеет все типы Parser и parse и связанные с ним функции.

---

Я понимаю, что это школьный проект и должен попробовать все возможное. У меня все еще есть еще две части, и это должно быть легкой частью.

Буду признателен, если кто-то может мне помочь.

Спасибо.

Answer 1

Основная проблема заключается в том, что тип LExpTree нуждается в дополнительном параметре типа, чтобы стать конкретным типом. Это, я считаю, это правильная версия lukVar:

lukVar :: Parser (LExpTree a) 
lukVar = do i <- ident; return (V i) 
     -- alternatively: V <$> ident 

Обратите внимание, что это анализатор для LExpTree a для любого типа a.

Сейчас, в lukLit, вы пытаетесь вернуть такие вещи, как L C. Я не вижу, где определено C, но давайте предположим, что тип C равен MyLits. Тогда подпись lukLit является:

lukLit :: Parser (LExpTree MyLits) 

Очевидно параметр типа a в LExpTree a является типом литералов, которые вы хотите использовать.

Обратите внимание на разницу между lukVar и lukLit - ваш код для lukVar будет работать с любым типом буквального, следовательно, переменная a в сигнатуре типа. Код для lukLit возвращает литералы от MyLits и таким образом возвращает LExpTree MyLits.

Теперь вы можете исправить lukExp. Я думаю, что это будет иметь подпись

lukExp :: Parser (LExpTree a) 

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