Haskell 中的建模交换

Question

我是 Haskell 的新手，我正在寻找为证券交易所库建模。它是一个库，因此由用户定义细节。我打算使用它的方式是让用户定义这样的东西。

data MyExchange = MyExchange { name :: ExchangeName
                             , base :: Currency
                             , quote :: Currency }
                             deriving (Eq, Show)

instance Exchange MyExchange

data MyExchangeBookMessage = 
        MyExchangeBookMessage { time :: Time
                              , exchange :: MyExchange
                              , price :: Price 
                              , side :: Side
                              , amount :: Maybe Amount }
                              deriving (Eq, Show)

instance ExchangeBookMessage MyExchangeBookMessage

我尝试了以下方法，但立即遇到了类型类的一些限制。下面是代码和错误信息。具体来说，用多种类型参数化类型类的替代方法是什么？

这是库的代码

module Lib where

data Side = Buy | Sell deriving (Eq, Show)

newtype Amount = Amount Rational deriving (Eq, Show)

newtype Price = Price Rational deriving (Eq, Show)

newtype Currency = Currency String deriving (Eq, Show)

newtype Time = Time Integer deriving (Eq, Show)

type ExchangeName = String

class Exchange a where
  name :: a -> ExchangeName
  base :: a -> Currency
  quote :: a -> Currency


class Message a where
  time :: a -> Time

class (Message a, Exchange e) => ExchangeMessage a e where
  exchange :: a -> e

class ExchangeMessage a b => BookMessage a b where
  price :: a -> Price
  side :: a -> Side
  amount :: a -> Maybe Amount

还有错误信息：

src/Lib.hs:22:1: error:
    • Too many parameters for class ‘ExchangeMessage’
      (Use MultiParamTypeClasses to allow multi-parameter classes)
    • In the class declaration for ‘ExchangeMessage’

以后我希望能够实现这样的类型类：

class Strategy s where
  run (Message m, Action a) => s -> m -> a

在Strategy 实现中，run 函数将采用抽象消息 m，将其与相关的 Message 数据构造函数进行模式匹配并返回特定操作。

我正在移植一些 Scala 代码。在 Scala 中，我在底部使用了带有具体案例类的特征层次结构：

trait Exchange { 
  def name: String
  def base: Currency
  def quote: Currency 
}

case class MyExchange(base: Currency, quote: Currency) {
  val name = "my-exchange"
}

trait Message {
  def time: Long
}

trait ExchangeMessage extends Message {
  def exchange: Exchange
}

trait BookMessage extends ExchangeMessage {
  def price: Double
  def side: Side
  def amount: Option[Double]
}

case class MyBookMessage(time: Long, price: Double, side: Side, amount: Option[Double]) {
  def exchange: Exchange = MyExchange(...)
}

Answer 1

首先，听从 GHC 的建议，在文件顶部启用MultiParamTypeCLasses。

{-# LANGUAGE MultiParamTypeClasses #-}

这是一个非常常见的扩展，它可以解决眼前的问题。

然而似乎存在一些建模问题，如果您继续进行此设计，您肯定会遇到一些您没有预料到的问题。我可以深入了解您的代码含义的所有细节，但我不确定这是否会很有帮助。相反，我认为我只会为您指出正确的方向，即使用data 记录而不是类型类。 Haskell 类型类与其他 OO 语言中的类不对应，这让许多初学者感到困惑。但我认为你想这样建模：

data Exchange = Exchange 
    { name :: ExchangeName
    , base :: Currency
    , quote :: Currency 
    }

data Message = Message
    { time :: Time }

-- etc.

这将为您简化一切，这更像是 OO 类而不是您的模型。请记住，记录可以将函数和其他复杂的数据结构作为字段，这就是您获得虚拟方法的模拟的方式，例如：

data MessageLogger = MessageLogger
    { log :: String -> IO () }

Answer 2

首先，您可能无法为ExchangeMessage 编写类实例。原因是exchange 函数必须能够返回any 类型e。如果你想保持这种方式，你需要提供一种方法来建立一个任意的交换！

class Exchange a where
  name :: a -> ExchangeName
  base :: a -> Currency
  quote :: a -> Currency
  build :: Time -> a

这是build 唯一可能的签名，因为您可以从交换中知道它有一个可以查询的Time，它可能没用。

我认为更好的设计是为您定义的所有这些类提供具体类型。例如：

data Exchange = Exchange { getName  :: ExchangeName
                         , getBase  :: Currency
                         , getQuote :: Currency
                         } deriving (Show, Eq)

然后，一旦您编写了适用于这些具体类型的函数，您就可以：

• 例如，编写MyExchange -> Exchange 类型的函数，以适应期望Exchange 的函数
• 使用经典镜头，以便直接编写会消耗任意类型的函数

总而言之，对于那种应用程序，如果您想对类型感兴趣，我建议您对货币使用幻像类型，这样您就可以静态强制执行，例如，您只能计算两个金额的总和使用相同货币的钱。使用类型类来模仿 OO 的习惯不会产生易于使用的 API 或清晰的代码。