Question

我正在为网格轴编写一个简单的ADT。在我的应用程序中，网格可以是常规的（在坐标之间有恒定的步长），也可以是不规则的（否则）。当然，常规网格只是不规则网格的一种特殊情况，但在某些情况下可能需要区分它们（例如，执行一些优化）。所以，我宣布我的ADT如下：

data GridAxis = RegularAxis (Float, Float) Float -- (min, max) delta
              | IrregularAxis [Float]            -- [xs]

但我不希望用户使用max < min或无序xs列表创建格式错误的轴。所以，我添加"smarter" construction functions执行一些基本检查：

regularAxis :: (Float, Float) -> Float -> GridAxis
regularAxis (a, b) dx = RegularAxis (min a b, max a b) (abs dx)

irregularAxis :: [Float] -> GridAxis
irregularAxis xs = IrregularAxis (sort xs)

我不希望用户直接创建网格，因此我不会将GridAxis数据构造函数添加到模块导出列表中：

module GridAxis (
    GridAxis,
    regularAxis,
    irregularAxis,
    ) where

但事实证明，完成此操作后，我无法在GridAxis上使用模式匹配。试图使用它

import qualified GridAxis as GA

test :: GA.GridAxis -> Bool
test axis = case axis of
              GA.RegularAxis -> True
              GA.IrregularAxis -> False

给出以下编译器错误：

src/Physics/ImplicitEMC.hs:7:15:
    Not in scope: data constructor `GA.RegularAxis'

src/Physics/ImplicitEMC.hs:8:15:
    Not in scope: data constructor `GA.IrregularAxis'

这有什么可以解决的吗？

Answer 1

您可以定义构造函数模式同义词。这使您可以使用相同的名称进行智能构建和＃34; dumb＆＃34;模式匹配。

{-# LANGUAGE PatternSynonyms #-}

module GridAxis (GridAxis, pattern RegularAxis, pattern IrregularAxis) where
import Data.List

data GridAxis = RegularAxis_ (Float, Float) Float -- (min, max) delta
              | IrregularAxis_ [Float]            -- [xs]

-- The line with "<-" defines the matching behavior
-- The line with "=" defines the constructor behavior
pattern RegularAxis minmax delta <- RegularAxis_ minmax delta where
  RegularAxis (a, b) dx = RegularAxis_ (min a b, max a b) (abs dx)

pattern IrregularAxis xs <- IrregularAxis_ xs where
  IrregularAxis xs = IrregularAxis_ (sort xs)

现在你可以做到：

module Foo
import GridAxis

foo :: GridAxis -> a
foo (RegularAxis (a, b) d) = ...
foo (IrregularAxis xs) = ...

并且还使用RegularAxis和IrregularAxis作为智能构造函数。

Answer 2

这看起来是pattern synonyms的一个用例。

基本上你不会导出真正的构造函数，但只有＃34; smart＆＃34;一个

{-# LANGUAGE PatternSynonyms #-}
module M(T(), SmartCons, smartCons) where

data T = RealCons Int

-- the users will construct T using this
smartCons :: Int -> T
smartCons n = if even n then RealCons n else error "wrong!"

-- ... and destruct T using this
pattern SmartCons n <- RealCons n

导入M的另一个模块可以使用

case someTvalue of
   SmartCons n -> use n

，例如

let value = smartCons 23 in ...

但不能直接使用RealCons。

如果您希望保留基本的Haskell，没有扩展名，则可以使用＆＃34;视图类型＆＃34;

module M(T(), smartCons, Tview(..), toView) where
data T = RealCons Int
-- the users will construct T using this
smartCons :: Int -> T
smartCons n = if even n then RealCons n else error "wrong!"

-- ... and destruct T using this
data Tview = Tview Int
toView :: T -> Tview
toView (RealCons n) = Tview n

在这里，用户可以完全访问视图类型，可以自由构造/销毁，但只有实际类型T的受限制的开始构造函数。通过移动到视图类型

，可以破坏实际类型T

case toView someTvalue of
  Tview n -> use n

对于嵌套模式，除非启用其他扩展程序，例如ViewPatterns，否则事情会变得更加麻烦。

私有数据构造函数上的模式匹配

2 个答案: