Комплексная государственная структура монады - PullRequest
Новая
       12

Комплексная государственная структура монады

3 голосов
/ 10 октября 2011

Я все еще новичок в Хаскеле, и я думаю, что сейчас у меня над головой. У меня есть код, который выглядит следующим образом. 

data World = World {
  intStack :: [Int],
  boolStack :: [Bool]
} deriving Show

instance IntStack World where
   getIntStack = intStack
   putIntStack ints (World _ bools) = World ints bools

instance BoolStack World where
    getBoolStack = boolStack
    putBoolStack bools (World ints _) = World ints bools

class IntStack a where
    getIntStack :: a -> [Int]
    putIntStack :: [Int] -> a -> a

class BoolStack a where
    getBoolStack :: a -> [Bool]
    putBoolStack :: [Bool] -> a -> a

(<=>) :: (IntStack c, BoolStack c) => c -> c
(<=>) w = putIntStack xs . putBoolStack ((x == x'):bs) $ w
    where (x:x':xs) = getIntStack w
          bs = getBoolStack w

(<+>) :: (IntStack c) => c -> c
(<+>) w = putIntStack ((x+x'):xs) w
    where (x:x':xs) = getIntStack w

Моя цель (на данный момент игнорирование случаев ошибок в функциях) заключается в возможности связывать воедино такие функции, как (<=>) и (<+>), предполагая, что базовый тип данных реализует необходимые интерфейсы функции.

Я чувствую, что могу многое исправить с помощью монады состояний, но я не уверен, как структурировать ее так, чтобы можно было вносить изменения в любой тип данных, который реализует IntStack, BoolStack и т. Д.

Я знаю, что это ужасно расплывчатое описание, но я чувствую, что приведенный выше код, возможно, является абсолютно неправильным способом.

Спасибо за любые отзывы!

Ответы [ 2 ]

5 голосов
/ 10 октября 2011 
class IntStack a where
    getIntStack :: a -> [Int]
    putIntStack :: [Int] -> a -> a

class BoolStack a where
    getBoolStack :: a -> [Bool]
    putBoolStack :: [Bool] -> a -> a

Поздравляю, вы только что изобрели линзы! Абстрагируйте типы [Int] и [Bool] и используйте data вместо class, и вы получите что-то вроде 

data Lens a b = Lens
    { get :: a -> b
    , put :: b -> a -> a
    }

... который реализован в полдюжине пакетов на Hackage. Большинство предложений по крайней мере:

  • возможность получения проекционных объективов, таких как getIntStack / putIntStack и getBoolStack / putBoolStack, непосредственно из объявления данных
  • горизонтальная композиция (работает сначала одна линза, затем вторая линза - например, сначала выбирается World из какой-то более крупной структуры, затем выбирается intStack из World) и вертикальная композиция (работает две линзы) параллельно, каждый на одной стороне пары)
  • некоторый интерфейс с State и StateT (например, что-то типа Lens a b -> State b r -> State a r), который позволит вам писать вычисления на [Bool] или [Int] и запускать их, как если бы они были вычислениями на World

Итак, проверьте взлом! Существует семейство data-lens, которое включает ядро ​​, способность получения и интерфейс с отслеживанием состояния ; объектив пакет; и пакет бессмысленных линз . Возможно, я тоже кое-что забыл.

1 голос
/ 10 октября 2011

Вы можете реализовать операции push и pop в монаде состояния и использовать их для реализации своих функций: 

popInt :: IntStack c => State c Int
popInt = do
  (x:xs) <- getIntStack <$> get
  modify $ putIntStack xs
  return x

pushInt :: IntStack c => Int -> State c ()
pushInt x = do
  xs <- getIntStack <$> get
  modify $ putIntStack (x:xs)

(<+>) :: IntStack c => State c ()
(<+>) = do 
  x <- popInt
  x' <- popInt
  pushInt (x + x')
...