Multiplate for the ZigZag data type.

ZigZagPlate.hs

import Control.Applicative
import Data.Functor.Constant
import Data.Generics.Multiplate

data ZigZag a b = ZNil | Zig a (ZigZag a b) | Zag b (ZigZag b a)

data ZigZagPlate a b f = ZigZagPlate 
                       { znilab :: f (ZigZag a b)
                       , zigab :: a -> ZigZag a b -> f (ZigZag a b)
                       , zagab :: b -> ZigZag b a -> f (ZigZag a b) 
                       , znilba :: f (ZigZag b a)
                       , zigba :: b -> ZigZag b a -> f (ZigZag b a) 
                       , zagba :: a -> ZigZag a b -> f (ZigZag b a) 
                       }

zzab :: ZigZagPlate a b f -> ZigZag a b -> f (ZigZag a b)
zzab plate ZNil = znilab plate
zzab plate (Zig a zz) = zigab plate a zz
zzab plate (Zag b zz) = zagab plate b zz
zzba :: ZigZagPlate a b f -> ZigZag b a -> f (ZigZag b a)
zzba plate ZNil = znilba plate
zzba plate (Zig b zz) = zigba plate b zz
zzba plate (Zag a zz) = zagba plate a zz

instance Multiplate (ZigZagPlate a b)
  where
    multiplate child = ZigZagPlate 
      (pure ZNil)
      (\a zz -> Zig <$> pure a <*> zzab child zz)
      (\b zz -> Zag <$> pure b <*> zzba child zz)
      (pure ZNil)
      (\b zz -> Zig <$> pure b <*> zzba child zz)
      (\a zz -> Zag <$> pure a <*> zzab child zz)
    mkPlate build = ZigZagPlate
      (build zzab ZNil)
      (\a zz -> build zzab (Zig a zz))
      (\b zz -> build zzab (Zag b zz))
      (build zzba ZNil)
      (\b zz -> build zzba (Zig b zz))
      (\a zz -> build zzba (Zag a zz))

zigs :: ZigZag a b -> [a]
zigs = foldFor zzab $ preorderFold $ purePlate { zigab = \a _ -> Constant [a]
                                               , zagba = \a _ -> Constant [a]
                                               }

zags :: ZigZag a b -> [b]
zags = foldFor zzab $ preorderFold $ purePlate { zigba = \b _ -> Constant [b]
                                               , zagab = \b _ -> Constant [b]
                                               }

zigzags :: ZigZag a a -> [a]
zigzags = foldFor zzab $ preorderFold $ purePlate { zigab = \a _ -> Constant [a]
                                                  , zigba = \b _ -> Constant [b]
                                                  , zagab = \b _ -> Constant [b]
                                                  , zagba = \a _ -> Constant [a]
                                                  }

test = Zig 'A' $ Zig 'B' $ Zag 'a' $ Zig 'b' $ Zag 'C' $ Zag 'c' $ ZNil