задействуя значение (Enum а, Bounded а) => а

Question

Я ищу пары функций

previous :: (Enum a, Bounded a) => a -> a 
next  :: (Enum a, Bounded a) => a -> a 

Такое, что previous является pred :: Enum a => a -> a, если полученное значение будет ограничен пределами, и цикл это на другую сторону в противном случае (симметрично для next и succ).

Пример

data X = A | B | C deriving (Bounded, Enum) 
next A = B 
next B = C 
next C = A 

Это было бы легко, если бы я добавить Eq a => a ограничение, как описано в этих similarquestions. Но это ограничение кажется ненужным, поскольку тип Bounded a => a для меня звучит так, как будто он должен быть в состоянии определить, находится ли он внутри или нет. В succ и pred сами функции имеют некоторый контроль над этим, но я предпочел бы не использовать исключения в моем иначе чистом коде:

Prelude> succ (maxBound :: Int) 
*** Exception: Prelude.Enum.succ{Int}: tried to take `succ' of maxBound 

Как succ/pred испытание против границ, не требуя Eq a => a (или даже Bounded a => a)? Могу ли я воспроизвести это поведение в своей собственной функции? Или существует другой способ написать функцию с таким поведением и не требует ограничения Eq?

Answer 1

Enum класс определяет две функции

toEnum :: Enum a => Int -> a 
    fromEnum :: Enum a => a -> Int 

Эти функции могут быть использованы для сравнения в Enum к другому, если диапазон этого Enum вписывается в размер Int. Если вы согласны принять это небольшое ограничение, вы можете написать свои функции следующим образом.

{-# LANGUAGE ScopedTypeVariables #-} 

previous :: forall a . (Enum a, Bounded a) => a -> a 
previous x | from x > from minBound = pred x 
      | otherwise    = maxBound where from :: a -> Int; from = fromEnum 

next :: forall a . (Enum a, Bounded a) => a -> a 
next x | from x < from maxBound = succ x 
     | otherwise    = minBound where from :: a -> Int; from = fromEnum 

Эти функции делают несколько предположений; что с учетом (Enum a, Bounded a) каждое значение a будет находиться между minBound и maxBound включительно и что {to/from}Enum сохранить этот заказ в отношении заказа на целые числа. Это справедливо для простых перечислений:

>import Control.Arrow 
>map (next &&& previous) [A,B,C] 
[(B,C),(C,A),(A,B)] 

Answer 2

Похоже, для некоторых из экземпляров класса типов, он просто определяет функцию, как вы сделали с вашим примером:

instance Enum Ordering where 
    succ LT = EQ 
    succ EQ = GT 
    succ GT = error "Prelude.Enum.Ordering.succ: bad argument" 

    pred GT = EQ 
    pred EQ = LT 
    pred LT = error "Prelude.Enum.Ordering.pred: bad argument" 

В противном случае, как вы говорите, это, кажется, наиболее вероятно, что вы собираетесь необходимо учитывать значение Eq, поскольку в принципе должно быть какое-то понятие сравнения (чтобы сравнить границы с текущим значением), если полное пространство типа не может быть легко перечислимо.

Answer 3

В чем проблема? Если вы можете добавить Eq класс тоже легко:

module CycleEnum where 

data XEnum = A1 | A2 | A3 deriving (Bounded, Enum, Eq, Show) 

cyclePrev :: (Eq a, Enum a, Bounded a) => a -> a 
cyclePrev x = if x == minBound then maxBound else pred x 

cycleNext :: (Eq a, Enum a, Bounded a) => a -> a 
cycleNext x = if x == maxBound then minBound else succ x 

Без Eq, это немного сложнее ...

module CycleEnum where 

data XEnum = A1 | A2 | A3 deriving (Bounded, Enum, Show) 

isSingle :: [a] -> Bool 
isSingle [x] = True 
isSingle _ = False 

isLastElement :: Enum a => a -> Bool 
isLastElement x = isSingle $ enumFrom x 

isFirstElement :: (Enum a, Bounded a) => a -> Bool 
isFirstElement x = isSingle $ enumFromTo minBound x 

cyclePrev :: (Enum a, Bounded a) => a -> a 
cyclePrev x = if isFirstElement x then maxBound else pred x 

cycleNext :: (Enum a, Bounded a) => a -> a 
cycleNext x = if isLastElement x then minBound else succ x 

Обратите внимание, что я написал isSingle с сопоставлением с образцом, а не по телефону length; потому что вычисление длины списка может быть очень неэффективным, если вы просто хотите знать, содержит ли список только один элемент.