与NEWTYPE包装

Question

创建奥德情况下，给定的数据类型，如

data Foo = Bar | Baz | Qux 

，我希望有多个不同的排序为这种类型，是下列最常见/标准来实现这种方式？

newtype FooPriorityA = FooPriorityA { unFooPriorityA :: Foo } 

instance Ord FooPriorityA where 
    compare (FooPriorityA x) (FooPriorityA y) = f x `compare` f y 
     where f :: Foo -> Int 
       f Baz = 1 
       f Bar = 2 
       f Qux = 3 

newtype FooPriorityB = FooPriorityB ... and so on 

委托给Int的Ord实例就像那样疯狂？与写出compare的n^2比较，感觉更安全，而且工作量更少。

我可能忽略了这个“黑客”的任何明显的缺陷？它甚至是“黑客”？

Answer 1

你只需要O（ñ）（2 ​ ñ - 1，要准确）定义来指定一个总订单，只要你按照优先顺序增加指定情况：

instance Ord FooPriorityA where 
    compare (FooPriorityA x) (FooPriorityA y) | x == y = EQ -- Use the Eq instance 
               -- Bar is the smallest 
               | x == Bar = LT 
               | y == Bar = GT 
               -- Baz is the next smallest 
               | x == Baz = LT 
               | y == Baz = GT 
               -- Proceed in the desired order. 
               -- You don't need to say anything 
               -- explicit about the largest value 

第一种情况（x == y）涵盖了O（n）种可能性。接下来的每个案例可能看起来都不完整，但它带有暗示的信息，即前面的每个案例都是错误的。例如，x == Bar = LT并不意味着每其中x == Bar评估为LT;已经处理了x == Bar && y == Bar的情况，所以第二种情况实际上是暗含x == Bar && y /= Bar。同样，案例4（x == Baz）假定y /= Baz（由案例1的失败暗示匹配）和y /= Bar（暗示情况3的匹配失败）。因此，y的任何剩余可能值实际上大于Baz。

你走下的列表越多，未处理的案例就越少。到最后，你不需要对最大的项目做任何明确的说明;所有关于它如何与其他对比的信息n - 上述情况已经捕获了1项。

---

另外，请记住，你的f定义为最小执行Enum类，然后你可以用它来定义Ord实例的实例中的一半（fromEnum）。

instance Enum FooPriorityA where 
    fromEnum Bar = 1 
    fromEnum Baz = 2 
    fromEnum Qux = 3 
    toEnum 1 = Bar 
    toEnum 2 = Baz 
    toEnum 3 = Qux 

instance Ord FooPriorityA where 
    compare x y = compare (fromEnum x) (fromEnum y) 
    -- compare = compare `on` Data.Function.fromEnum 

Answer 2

这是绝对合理的。事实上，你可以使用the comparing function from Data.Ord使这更是直接：

instance Ord FooPriorityA where 
    compare (FooPriorityA x) (FooPriorityA y) = comparing f x y 
    where f :: Foo -> Int 
      f Baz = 1 
      f Bar = 2 
      f Qux = 3 

虽然根据自己的喜好，与compare版本可能会根据自己的喜好。

Answer 3

如何做一个函数来生成映射从Foo基于表示要订购名单上Int：

import Data.List 

data Foo = Bar | Baz | Qux deriving Eq 

newtype FooPriorityA = FooPriorityA { unFooPriorityA :: Foo } deriving Eq 

fooOrdering :: [Foo] -> Foo -> Foo -> Ordering 
fooOrdering orderedList a b = f a `compare` f b 
    where f x = elemIndex x orderedList 

instance Ord FooPriorityA where 
    compare (FooPriorityA x) (FooPriorityA y) = fooOrdering [Baz, Bar, Qux] x y 

你甚至可以添加断言，以确保所有元素出现一次在列表中。