可能无法匹配类型变量

Question

我正在尝试使用相当特定的体系结构（有限状态机）创建电报机器人。例如，可能会有（1）状态可以运行某些功能，该状态将返回其他状态或（2）状态，该状态将将bot移至其他具有不同状态的机器。

因此，我创建了类似的类别和两种类型：

{-# LANGUAGE DeriveAnyClass, GADTs #-}
module Main where

class (Eq a) => TeleClass a

type BotView a = String -> a

data TeleState a where
    TeleState :: TeleClass a => a -> BotView a -> TeleState a
    TeleMachineChange :: (TeleClass a, TeleClass b) => a -> TeleMachine b -> TeleState a

data TeleMachine a = TeleMachine
    { defaultState :: a
    , stateMachine :: [TeleState a]
    }

然后GHC允许我创建一些看起来完全像我想要的FSM：

data MainStates = MAIN_MENU | TASK_CHOOSING | CHANGE_VIEW | MODER_VIEW
    deriving (TeleClass, Eq)
data AdminStates = ADMIN_MENU | PUBLISH_TASK
    deriving (TeleClass, Eq)
data ModerStates = MODER_MENU | EDIT_TASK
    deriving (TeleClass, Eq)

fMainMenu _  = TASK_CHOOSING
fChooseTask _ = CHANGE_VIEW

fAdminMenu _ = PUBLISH_TASK
fPublishTask _ = ADMIN_MENU

fModerMenu _ = EDIT_TASK
fEditTask _ = MODER_MENU

moderMachine = TeleMachine
    { defaultState = MODER_MENU
    , stateMachine =
        [ TeleState MODER_MENU fModerMenu
        , TeleState EDIT_TASK fEditTask
        ]
    }

adminMachine = TeleMachine
    { defaultState = ADMIN_MENU
    , stateMachine =
        [ TeleState ADMIN_MENU fAdminMenu
        , TeleState PUBLISH_TASK fPublishTask
        ]
    }

mainMachine = TeleMachine
    { defaultState = MAIN_MENU
    , stateMachine =  
        [ TeleState MAIN_MENU fMainMenu
        , TeleState TASK_CHOOSING fChooseTask
        , TeleMachineChange CHANGE_VIEW adminMachine
        , TeleMachineChange MODER_VIEW moderMachine
        ] 
    }

然后将一些状态应用于FSM，我添加了此功能：

data MatchResult a b = Func a | Machine b | None

matchState :: (TeleClass a, TeleClass c) =>
    [TeleState a] -> a -> MatchResult (BotView a) (TeleMachine c)
matchState (TeleState mState fFunc : stateMachine) state
    | mState == state = Func fFunc
    | otherwise = matchState stateMachine state
matchState (TeleMachineChange mState mMachine : stateMachine) state
    | mState == state = Machine mMachine
    | otherwise = matchState stateMachine state
matchState [] _ = None

编译器抱怨它无法与“ C”类型匹配：

    • Couldn't match type ‘b’ with ‘c’
      ‘b’ is a rigid type variable bound by
        a pattern with constructor:
          TeleMachineChange :: forall a b.
                               (TeleClass a, TeleClass b) =>
                               a -> TeleMachine b -> TeleState a,
        in an equation for ‘matchState’
        at example.hs:70:13-45
      ‘c’ is a rigid type variable bound by
        the type signature for:
          matchState :: forall a c.
                        (TeleClass a, TeleClass c) =>
                        [TeleState a] -> a -> MatchResult (BotView a) (TeleMachine c)
        at example.hs:(65,1)-(66,65)
      Expected type: MatchResult (BotView a) (TeleMachine c)
        Actual type: MatchResult (BotView a) (TeleMachine b)
    • In the expression: Machine mMachine
      In an equation for ‘matchState’:
          matchState (TeleMachineChange mState mMachine : stateMachine) state
            | mState == state = Machine mMachine
            | otherwise = matchState stateMachine state
    • Relevant bindings include
        mMachine :: TeleMachine b (bound at example.hs:70:38)
        matchState :: [TeleState a]
                      -> a -> MatchResult (BotView a) (TeleMachine c)
          (bound at example.hs:67:1)
   |
71 |     | mState == state = Machine mMachine
   |                         ^^^^^^^^^^^^^^^^

我尝试使用存在量的量化和量化限制扩展，但无法解决此问题。现在，我不知道这是否可行，可以在Haskell之类的语言中实现类似的内容。

Answer 1

签名

matchState :: (TeleClass a, TeleClass c) =>
    [TeleState a] -> a -> MatchResult (BotView a) (TeleMachine c)

...这只是

matchState :: ∀ a c . (TeleClass a, TeleClass c) =>
    [TeleState a] -> a -> MatchResult (BotView a) (TeleMachine c)

表达的速记，即对于c呼叫者选择的任何类型，此功能将能够从输入列表中获取合适的telemachine。这似乎是一件艰难的事情。

我认为您要表达的是“好的，我会尝试在其中找到一台匹配的机器，但我不知道它的类型是什么”。确实，这确实是存在类型

matchState :: ∀ a . ∃ c . (TeleClass a, TeleClass c) =>
    [TeleState a] -> a -> MatchResult (BotView a) (TeleMachine c)

haskell不允许使用存在类型的功能，但是您可以使matchResult类型存在，与telemachinechange telemachine的构造函数是存在的：

data MatchResult a where
  Func :: a -> MatchResult a
  Machine :: TeleClass b => b -> MatchResult a
  None :: MatchResult a

matchState :: ∀ a . TeleClass a =>
    [TeleState a] -> a -> MatchResult (BotView a)

或者，您可以使用持续通话风格的matchstate伪造存在类型：

matchState :: ∀ a r . TeleClass a =>
     [TeleState a]
  -> a
  -> (∀ c . TeleClass a
       => MatchResult (BotView a) (TeleMachine c) -> r)
  -> r
matchState (TeleState mState fFunc : stateMachine) state φ
    | mState == state = φ (Func fFunc)
    | otherwise = matchState stateMachine state φ
matchState (TeleMachineChange mState mMachine : stateMachine) state
    | mState == state = φ (Machine mMachine)
    | otherwise = matchState stateMachine state φ
matchState [] _ = φ None