content: {-# LANGUAGE CPP, GeneralizedNewtypeDeriving #-}
  -----------------------------------------------------------------------------
  -- |
  -- Module      :  XMonad.Hooks.DebugEvents
  -- Copyright   :  (c) Brandon S Allbery KF8NH, 2012
  -- License     :  BSD3-style (see LICENSE)
  --
  -- Maintainer  :  allbery.b@gmail.com
  -- Stability   :  unstable
  -- Portability :  not portable
  --
  -- Module to dump diagnostic information about X11 events received by
  -- @xmonad@.  This is incomplete due to 'Event' being incomplete and not
  -- providing information about a number of events, and enforcing artificial
  -- constraints on others (for example 'ClientMessage'); the @X11@ package
  -- will require a number of changes to fix these problems.
  --
  -----------------------------------------------------------------------------
  
  module XMonad.Hooks.DebugEvents (debugEventsHook) where
  
  import           Prelude
  
  import           XMonad                               hiding (windowEvent
                                                               ,(-->)
                                                               )
  
  import           XMonad.Hooks.DebugKeyEvents                 (debugKeyEvents)
  import           XMonad.Util.DebugWindow                     (debugWindow)
  
  -- import           Graphics.X11.Xlib.Extras.GetAtomName        (getAtomName)
  
  import           Control.Exception.Extensible         as E
  import           Control.Monad.State
  import           Control.Monad.Reader
  import           Data.Char                                   (isDigit)
  import           Data.List                                   (genericIndex
                                                               ,genericLength
                                                               ,unfoldr
                                                               )
  import           Codec.Binary.UTF8.String
  import           Data.Maybe                                  (fromMaybe)
  import           Data.Monoid
  import           Foreign
  import           Foreign.C.Types
  import           Numeric                                     (showHex)
  import           System.Exit
  import           System.IO
  import           System.Process
  import           Control.Applicative
  
  -- | Event hook to dump all received events.  You should probably not use this
  --   unconditionally; it will produce massive amounts of output.
  debugEventsHook   :: Event -> X All
  debugEventsHook e =  debugEventsHook' e >> return (All True)
  
  -- | Dump an X11 event.  Can't be used directly as a 'handleEventHook'.
  debugEventsHook' :: Event -> X ()
  
  debugEventsHook' (ConfigureRequestEvent {ev_window       = w
                                          ,ev_parent       = p
                                          ,ev_x            = x
                                          ,ev_y            = y
                                          ,ev_width        = wid
                                          ,ev_height       = ht
                                          ,ev_border_width = bw
                                          ,ev_above        = above
                                          ,ev_detail       = place
                                          ,ev_value_mask   = msk
                                          }) = do
    windowEvent "ConfigureRequest" w
    windowEvent "  parent"         p
  --  mask <- quickFormat msk $ dumpBits wmCRMask
  --  say "  requested parameters" $ concat ['(':show wid
  --                                        ,'x':show ht
  --                                        ,')':if bw == 0 then "" else '+':show bw
  --                                        ,'@':'(':show x
  --                                        ,',':show y
  --                                        ,") mask "
  --                                        ,mask
  --                                        ]
    s <- quickFormat [x,y,wid,ht,bw,fromIntegral above,place] $
         dumpListByMask' msk [("x"           ,dump32              ,cARDINAL)
                             ,("y"           ,dump32              ,cARDINAL)
                             ,("width"       ,dump32              ,cARDINAL)
                             ,("height"      ,dump32              ,cARDINAL)
                             ,("border_width",dump32              ,cARDINAL)
                             ,("sibling"     ,dumpWindow          ,wINDOW  )
                             ,("detail"      ,dumpEnum wmPlacement,cARDINAL)
                             ]
    say "  requested" s
  
  debugEventsHook' (ConfigureEvent        {ev_window = w
                                          ,ev_above  = above
                                          }) = do
    windowEvent "Configure" w
    -- most of the content is covered by debugWindow
    when (above /= none) $ debugWindow above >>= say "  above"
  
  debugEventsHook' (MapRequestEvent       {ev_window     = w
                                          ,ev_parent     = p
                                          }) =
    windowEvent "MapRequest" w >>
    windowEvent "  parent"   p
  
  debugEventsHook' e@(KeyEvent {ev_event_type = t})
      | t == keyPress =
    io (hPutStr stderr "KeyPress ") >>
    debugKeyEvents e >>
    return ()
  
  debugEventsHook' (ButtonEvent           {ev_window = w
                                          ,ev_state  = s
                                          ,ev_button = b
                                          }) = do
    windowEvent "Button" w
    nl <- gets numberlockMask
    let msk | s == 0    = ""
            | otherwise = "modifiers " ++ vmask nl s
    say "  button" $ show b ++ msk
  
  debugEventsHook' (DestroyWindowEvent    {ev_window = w
                                          }) =
    windowEvent "DestroyWindow" w
  
  debugEventsHook' (UnmapEvent            {ev_window = w
                                          }) =
    windowEvent "Unmap" w
  
  debugEventsHook' (MapNotifyEvent        {ev_window = w
                                          }) =
    windowEvent "MapNotify" w
  
  {- way too much output; suppressed.
  
  debugEventsHook' (CrossingEvent         {ev_window    = w
                                          ,ev_subwindow = s
                                          }) =
    windowEvent "Crossing"    w >>
    windowEvent "  subwindow" s
  -}
  debugEventsHook' (CrossingEvent         {}) =
    return ()
  
  debugEventsHook' (SelectionRequest      {ev_requestor = rw
                                          ,ev_owner     = ow
                                          ,ev_selection = a
                                          }) =
    windowEvent "SelectionRequest" rw >>
    windowEvent "  owner"          ow >>
    atomEvent   "  atom"           a
  
  debugEventsHook' (PropertyEvent         {ev_window    = w
                                          ,ev_atom      = a
                                          ,ev_propstate = s
                                          }) = do
    a' <- atomName a
    -- too many of these, and they're not real useful
    if a' `elem` ["_NET_WM_USER_TIME"
  --               ,"_NET_WM_WINDOW_OPACITY"
                 ] then return () else do
    windowEvent "Property on" w
    s' <- case s of
            1 -> return "deleted"
            0 -> dumpProperty a a' w (7 + length a')
            _ -> error "Illegal propState; Xlib corrupted?"
    say "  atom" $ a' ++ s'
  
  debugEventsHook' (ExposeEvent           {ev_window = w
                                          }) =
    windowEvent "Expose" w
  
  debugEventsHook' (ClientMessageEvent    {ev_window       = w
                                          ,ev_message_type = a
                                          -- @@@ they did it again!  no ev_format,
                                          --     and ev_data is [CInt]
                                          -- @@@ and get a load of the trainwreck
                                          --     that is setClientMessageEvent!
  --                                        ,ev_format       = b
                                          ,ev_data         = vs'
                                          }) = do
    windowEvent "ClientMessage on" w
    n <- atomName a
    -- this is a sort of custom property
    -- @@@ this likely won't work as is; type information varies, I think
    (ta,b,l) <- case lookup n clientMessages of
                  Nothing        -> return (a,32,length vs')
                  Just (ta',b,l) -> do
                    ta <- getAtom ta'
                    return (ta,b,l)
    let wl = bytes b
    vs <- io $ take (l * wl) `fmap` splitCInt vs'
    s <- dumpProperty' w a n ta b vs 0 (10 + length n)
    say "  message" $ n ++ s
  
  debugEventsHook' _                      = return ()
  
  -- | Emit information about an atom.
  atomName   :: Atom -> X String
  atomName a =  withDisplay $ \d ->
    io $ fromMaybe ("(unknown atom " ++ show a ++ ")") `fmap` getAtomName d a
  
  -- | Emit an atom with respect to the current event.
  atomEvent     :: String -> Atom -> X ()
  atomEvent l a =  atomName a >>= say l
  
  -- | Emit a window with respect to the current event.
  windowEvent     :: String -> Window -> X ()
  windowEvent l w =  debugWindow w >>= say l
  
  -- | Helper to emit tagged event information.
  say     :: String -> String -> X ()
  say l s =  trace $ l ++ ' ':s
  
  -- | Deconstuct a list of 'CInt's into raw bytes
  splitCInt    :: [CInt] -> IO Raw
  splitCInt vs =  io $ withArray vs $ \p ->
                  peekArray (4 * length vs) (castPtr p :: Ptr CUChar)
  
  -- | Specify how to decode some common client messages.
  clientMessages :: [(String,(String,Int,Int))]
  clientMessages =  [("_NET_ACTIVE_WINDOW",("_NET_ACTIVE_WINDOW",32,1))
                    ,("WM_CHANGE_STATE"   ,("WM_STATE"          ,32,2))
                    ,("WM_COMMAND"        ,("STRING"            , 8,0))
                    ,("WM_SAVE_YOURSELF"  ,("STRING"            , 8,0))
                    ]
  
  #if __GLASGOW_HASKELL__ < 707
  finiteBitSize :: Bits a => a -> Int
  finiteBitSize x = bitSize x
  #endif
  
  
  -- | Convert a modifier mask into a useful string
  vmask                 :: KeyMask -> KeyMask -> String
  vmask numLockMask msk =  unwords $
                           reverse $
                           fst     $
                           foldr vmask' ([],msk) masks
      where
        masks = map (\m -> (m,show m)) [0..toEnum (finiteBitSize msk - 1)] ++
                [(numLockMask,"num"  )
                ,(   lockMask,"lock" )
                ,(controlMask,"ctrl" )
                ,(  shiftMask,"shift")
                ,(   mod5Mask,"mod5" )
                ,(   mod4Mask,"mod4" )
                ,(   mod3Mask,"mod3" )
                ,(   mod2Mask,"mod2" )
                ,(   mod1Mask,"mod1" )
                ]
        vmask'   _   a@( _,0)                = a
        vmask' (m,s)   (ss,v) | v .&. m == m = (s : ss,v .&. complement m)
        vmask'   _        r                  = r
  
  -- formatting properties.  ick. --
  
  -- @@@ Document the parser.  Someday.
  
  type Raw     = [CUChar]
  
  data Decode = Decode {property :: Atom          -- original property atom
                       ,pName    :: String        -- its name
                       ,pType    :: Atom          -- base property type atom
                       ,width    :: Int           -- declared data width
                       ,window   :: Window        -- source window
                       ,indent   :: Int           -- current indent (via local)
                       ,limit    :: Int           -- line length
                       }
  
  -- the result accumulates here mainly for the benefit of the indenter
  data DecodeState = DecS {value :: Raw           -- unconsumed raw property value
                          ,accum :: String        -- output accumulator
                          ,joint :: String        -- separator when adding to accumulator
                          }
  
  newtype Decoder a = Decoder (ReaderT Decode (StateT DecodeState X) a)
  #ifndef __HADDOCK__
      deriving (Functor
               ,Applicative
               ,Monad
               ,MonadIO
               ,MonadState  DecodeState
               ,MonadReader Decode
               )
  #endif
  
  -- | Retrive, parse, and dump a window property.  As all the high-level property
  --   interfaces lose information necessary to decode properties correctly, we 
  --   work at the lowest level available.
  dumpProperty          :: Atom -> String -> Window -> Int -> X String
  dumpProperty a n w i  =  do
    prop <- withDisplay $ \d ->
      io     $
      alloca $ \fmtp ->
      alloca $ \szp  ->
      alloca $ \lenp ->
      alloca $ \ackp ->
      alloca $ \vsp  -> do
      rc   <- xGetWindowProperty
                d
                w
                a
                0
                maxBound
                False
                anyPropertyType
                fmtp
                szp
                lenp
                ackp
                vsp
      case rc of
        0 -> do
          fmt <- fromIntegral `fmap` peek fmtp
          vs' <-                     peek vsp
          sz  <- fromIntegral `fmap` peek szp
          case () of
            () | fmt == none     -> xFree vs' >> return (Left   "(property deleted)"   )
               | sz < 0          -> xFree vs' >> return (Left $ "(illegal bit size " ++
                                                                show sz              ++
                                                                ")"                    )
               | sz `mod` 8 /= 0 -> xFree vs' >> return (Left $ "(illegal bit size " ++
                                                                show sz              ++
                                                                ")"                    )
               | otherwise       -> do
                   len <- fromIntegral `fmap` peek lenp
                   -- that's as in "ack! it's fugged!"
                   ack <- fromIntegral `fmap` peek ackp
                   vs <- peekArray (len * bytes sz) vs'
                   _ <- xFree vs'
                   return $ Right (fmt,sz,ack,vs)
        e -> return $ Left $ "getWindowProperty failed: " ++ show e
    case prop of
      Left  _               -> return ""
      Right (fmt,sz,ack,vs) -> dumpProperty' w a n fmt sz vs ack i
  
  -- @@@ am I better off passing in the Decode and DecodeState?
  -- | Parse and dump a property (or a 'ClientMessage').
  dumpProperty'                             :: Window -- source window
                                            -> Atom   -- property id
                                            -> String -- property name
                                            -> Atom   -- property type
                                            -> Int    -- bit width
                                            -> Raw    -- raw value
                                            -> CULong -- size of un-dumped content
                                            -> Int    -- indent for output formatting
                                            -> X String
  dumpProperty' w a n fmt sz vs ack i =  do
    ptn <- atomName fmt
    let dec  = Decode {property = a
                      ,pName    = n
                      ,pType    = fmt
                      ,width    = sz
                      ,indent   = i + length ptn + 6
                      ,window   = w
                      ,limit    = 96
                      }
        dec' = dec    {pType    = cARDINAL
                      ,width    = 8
                      }
        ds   = DecS   {value    = vs
                      -- @@@ probably should push this outside, since it doesn't
                      --     make sense for ClientMessage
                      ,accum    = " (" ++ ptn ++ ") "
                      ,joint    = "= "
                      }
    (_,ds') <- runDecode dec ds $ dumpProp a n
    let fin = length (value ds')
        len = length vs
        lost = if ack == 0 then "" else "and " ++ show ack ++ " lost bytes"
        unk = case () of
                () | fin == len -> "undecodeable "
                   | fin == 0   -> "."
                   | otherwise  -> "and remainder (" ++ show (len - fin) ++ '/':show len ++ ")"
    (_,ds'') <- if fin == 0
                then return (True,ds')
                else runDecode dec' (withJoint' unk ds' ) $ dumpArray dump8
    (_,ds''') <- if ack == 0
                 then return (True,ds'')
                 else runDecode dec' (withJoint' " " ds'') $ propSimple lost -- @@@
    return $ accum ds'''
  
  -- | A simplified version of 'dumpProperty\'', to format random values from
  --   events.
  quickFormat     :: (Storable i, Integral i) => [i] -> Decoder Bool -> X String
  quickFormat v f =  do
    let vl = length v
    vs <- io $
          allocaArray vl $
          \p -> pokeArray p (map fromIntegral v :: [CULong]) >>
                peekArray (4 * vl) (castPtr p :: Ptr CUChar)
    let dec = Decode {property = none
                     ,pName    = ""
                     ,pType    = cARDINAL
                     ,width    = 32
                     ,indent   = 0
                     ,window   = none
                     ,limit    = maxBound
                     }
        ds  = DecS   {value    = vs
                     ,accum    = ""
                     ,joint    = ""
                     }
    (r,ds') <- runDecode dec ds f
    return $ accum ds' ++ if r then "" else "?"
  
  -- | Launch a decoding parser, returning success and final state.
  runDecode                 :: Decode -> DecodeState -> Decoder Bool -> X (Bool,DecodeState)
  runDecode c s (Decoder p) =  runStateT (runReaderT p c) s
  
  -- Coerce bit size to bytes.
  bytes   :: Int -> Int
  bytes w =  w `div` 8
  
  -- | The top level property decoder, for a wide variety of standard ICCCM and 
  --   EWMH window properties.  We pass part of the 'ReaderT' as arguments for 
  --   pattern matching.
  dumpProp                                              :: Atom -> String -> Decoder Bool
  
  dumpProp _ "CLIPBOARD"                                =  dumpSelection
  dumpProp _ "_NET_SUPPORTED"                           =  dumpArray dumpAtom
  dumpProp _ "_NET_CLIENT_LIST"                         =  dumpArray dumpWindow
  dumpProp _ "_NET_CLIENT_LIST_STACKING"                =  dumpArray dumpWindow
  dumpProp _ "_NET_NUMBER_OF_DESKTOPS"                  =  dump32
  dumpProp _ "_NET_VIRTUAL_ROOTS"                       =  dumpArray dumpWindow
  dumpProp _ "_NET_DESKTOP_GEOMETRY"                    =  dumpArray dump32
  dumpProp _ "_NET_DESKTOP_VIEWPORT"                    =  dumpList [("w",dump32)
                                                                    ,("h",dump32)
                                                                    ]
  dumpProp _ "_NET_CURRENT_DESKTOP"                     =  dump32
  dumpProp _ "_NET_DESKTOP_NAMES"                       =  dumpArray dumpUTF
  dumpProp _ "_NET_ACTIVE_WINDOW"                       =  dumpActiveWindow
  dumpProp _ "_NET_WORKAREA"                            =  dumpList [("start"
                                                                     ,dumpList [("x",dump32)
                                                                               ,("y",dump32)
                                                                               ]
                                                                     )
                                                                    ,("size"
                                                                     ,dumpList [("w",dump32)
                                                                               ,("h",dump32)
                                                                               ]
                                                                     )
                                                                    ]
  dumpProp _ "_NET_SUPPORTING_WM_CHECK"                 =  dumpWindow
  dumpProp _ "_NET_DESKTOP_LAYOUT"                      =  dumpList [("orientation"
                                                                     ,dumpEnum nwmOrientation
                                                                     )
                                                                    ,("size"
                                                                     ,dumpList [("cols",dump32)
                                                                               ,("rows",dump32)
                                                                               ]
                                                                     )
                                                                    ,("origin"
                                                                     ,dumpEnum nwmOrigin
                                                                     )
                                                                    ]
  dumpProp _ "_NET_SHOWING_DESKTOP"                     =  dump32
  dumpProp _ "_NET_WM_NAME"                             =  dumpUTF
  dumpProp _ "_NET_WM_VISIBLE_NAME"                     =  dumpUTF
  dumpProp _ "_NET_WM_ICON_NAME"                        =  dumpUTF
  dumpProp _ "_NET_WM_VISIBLE_ICON_NAME"                =  dumpUTF
  dumpProp _ "_NET_WM_DESKTOP"                          =  dumpExcept [(0xFFFFFFFF,"all")]
                                                                      dump32
  dumpProp _ "_NET_WM_WINDOW_TYPE"                      =  dumpArray dumpAtom
  dumpProp _ "_NET_WM_STATE"                            =  dumpArray dumpAtom
  dumpProp _ "_NET_WM_ALLOWED_ACTIONS"                  =  dumpArray dumpAtom
  dumpProp _ "_NET_WM_STRUT"                            =  dumpList [("left gap"  ,dump32)
                                                                    ,("right gap" ,dump32)
                                                                    ,("top gap"   ,dump32)
                                                                    ,("bottom gap",dump32)
                                                                    ]
  dumpProp _ "_NET_WM_STRUT_PARTIAL"                    =  dumpList [("left gap"    ,dump32)
                                                                    ,("right gap"   ,dump32)
                                                                    ,("top gap"     ,dump32)
                                                                    ,("bottom gap"  ,dump32)
                                                                    ,("left start"  ,dump32)
                                                                    ,("left end"    ,dump32)
                                                                    ,("right start" ,dump32)
                                                                    ,("right end"   ,dump32)
                                                                    ,("top start"   ,dump32)
                                                                    ,("top end"     ,dump32)
                                                                    ,("bottom start",dump32)
                                                                    ,("bottom end"  ,dump32)
                                                                    ]
  dumpProp _ "_NET_WM_ICON_GEOMETRY"                    =  dumpList [("x",dump32)
                                                                    ,("y",dump32)
                                                                    ,("w",dump32)
                                                                    ,("h",dump32)
                                                                    ]
  -- no, I'm not going to duplicate xprop *completely*!
  dumpProp _ "_NET_WM_ICON"                             =  propSimple "(icon)"
  dumpProp _ "_NET_WM_PID"                              =  dumpPid
  dumpProp _ "_NET_WM_HANDLED_ICONS"                    =  propSimple "(defined)"
  dumpProp _ "_NET_WM_USER_TIME"                        =  dumpExcept [(0,"do not map initially")]
                                                                      dumpTime
  dumpProp _ "_NET_FRAME_EXTENTS"                       =  dumpList [("left"  ,dump32)
                                                                    ,("right" ,dump32)
                                                                    ,("top"   ,dump32)
                                                                    ,("bottom",dump32)
                                                                    ]
  dumpProp _ "_NET_WM_SYNC_REQUEST_COUNTER"             =  dumpExcept [(0,"illegal value 0")]
                                                                      dump64
  dumpProp _ "_NET_STARTUP_ID"                          =  dumpUTF
  dumpProp _ "WM_PROTOCOLS"                             =  dumpArray dumpAtom
  dumpProp _ "WM_COLORMAP_WINDOWS"                      =  dumpArray dumpWindow
  dumpProp _ "WM_STATE"                                 =  dumpState
  dumpProp _ "WM_LOCALE_NAME"                           =  dumpString
  dumpProp _ "WM_CLIENT_LEADER"                         =  dumpWindow
  dumpProp _ "_NET_WM_WINDOW_OPACITY"                   =  dumpPercent
  dumpProp _ "XdndAware"                                =  dumpArray dumpAtom
  dumpProp _ "_XKLAVIER_TRANSPARENT"                    =  dumpInteger 32
  dumpProp _ "_XKLAVIER_STATE"                          =  dumpList [("state"     ,dumpInteger 32)
                                                                    ,("indicators",dumpXKlInds)
                                                                    ]
  dumpProp _ "_MOTIF_DRAG_RECEIVER_INFO"                =  dumpMotifDragReceiver
  dumpProp _ "_OL_WIN_ATTR"                             =  dumpOLAttrs
  dumpProp _ "_OL_DECOR_ADD"                            =  dumpArray dumpAtom
  dumpProp _ "_OL_DECOR_DEL"                            =  dumpArray dumpAtom
  dumpProp _ "_MOTIF_WM_HINTS"                          =  dumpMwmHints
  dumpProp _ "_MOTIF_WM_INFO"                           =  dumpMwmInfo
  dumpProp _ "_XMONAD_DECORATED_BY"                     =  dumpWindow
  dumpProp _ "_XMONAD_DECORATION_FOR"                   =  dumpWindow
  dumpProp a _ | a == wM_NAME                           =  dumpString
               | a == pRIMARY                           =  dumpSelection
               | a == sECONDARY                         =  dumpSelection
                 -- this is gross
               | a == wM_TRANSIENT_FOR                  =  do
                   root <- fromIntegral `fmap` inX (asks theRoot)
                   w <- asks window
                   WMHints {wmh_window_group = group} <-
                     inX $ asks display >>= io . flip getWMHints w
                   dumpExcept [(0   ,"window group " ++ show group)
                              ,(root,"window group " ++ show group)
                              ]
                              dumpWindow
               | a == rESOURCE_MANAGER                  =  dumpString
               | a == wM_COMMAND                        =  dumpString
               | a == wM_HINTS                          =  dumpWmHints
               | a == wM_CLIENT_MACHINE                 =  dumpString
               | a == wM_ICON_NAME                      =  dumpString
               | a == wM_ICON_SIZE                      =  dumpList [("min size"
                                                                     ,dumpList [("w",dump32)
                                                                               ,("h",dump32)
                                                                               ]
                                                                     )
                                                                    ,("max size"
                                                                     ,dumpList [("w",dump32)
                                                                               ,("h",dump32)
                                                                               ]
                                                                     )
                                                                    ,("increment"
                                                                     ,dumpList [("w",dump32)
                                                                               ,("h",dump32)
                                                                               ]
                                                                     )
                                                                    ]
               | a == wM_NORMAL_HINTS                   =  (...)
               | a == wM_ZOOM_HINTS                     =  (...) -- same as previous
               | a == rGB_DEFAULT_MAP                   =  (...) -- XStandardColormap
               | a == rGB_BEST_MAP                      =  (...) -- "
               | a == rGB_RED_MAP                       =  (...) -- "
               | a == rGB_GREEN_MAP                     =  (...) -- "
               | a == rGB_BLUE_MAP                      =  (...) -- "
               | a == rGB_GRAY_MAP                      =  (...) -- "
               | a == wM_CLASS                          =  dumpList [("name" ,dumpString)
                                                                    ,("class",dumpString)
                                                                    ]
  dumpProp _ s | s `isCountOf` "WM_S"                   =  dumpSelection
               | s `isCountOf` "_NET_WM_CM_S"           =  dumpSelection
               | s `isCountOf` "_NET_DESKTOP_LAYOUT_S"  =  dumpSelection
               | s `isCountOf` "CUT_BUFFER"             =  dumpString
               -- and dumpProperties does the rest
               | otherwise                              =  return False
  
  -- lower level decoders --
  
  -- alter the current joint
  withJoint   :: String -> Decoder a -> Decoder a
  withJoint j =  ((modify $ withJoint' j) >>)
  
  withJoint'     :: String -> DecodeState -> DecodeState
  withJoint' j s =  s {joint = j}
  
  -- lift an X into a Decoder
  inX :: X a -> Decoder a
  inX =  Decoder . lift . lift
  
  -- flip isPrefixOf, but the remainder must be all digits
  isCountOf         :: String -> String -> Bool
  -- note that \NUL is safe because atom names have to be C strings
  s `isCountOf` pfx =  null                     $
                       dropWhile isDigit        $
                       map fst                  $
                       dropWhile (uncurry (==)) $
                       zip s                    $
                       pfx ++ repeat '\NUL'
  
  -- localize an increased indent
  withIndent   :: Int -> Decoder a -> Decoder a
  withIndent w =  local (\r -> r {indent = indent r + w})
  
  -- dump an array of items.  this dumps the entire property
  dumpArray      :: Decoder Bool -> Decoder Bool
  dumpArray item =  do
    withIndent 1 $ append "[" >> withJoint "" (dumpArray' item "")
  
  -- step through values as an array, ending on parse error or end of list
  dumpArray'          :: Decoder Bool -> String -> Decoder Bool
  dumpArray' item pfx =  do
    vs <- gets value
    if vs == []
      then append "]"
      else append pfx >> whenD item (dumpArray' item ",")
  
  -- keep parsing until a parse step fails
  -- @@@ which points out that all my uses of @whenX (return ...)@ are actually 'when',
  --     which suggests that 'whenX' is *also* the same function... yep.  ISAGN
  whenD     :: Monad m => m Bool -> m Bool -> m Bool
  whenD p f =  p >>= \b -> if b then f else return False
  
  -- verify a decoder parameter, else call error reporter
  -- once again, it's more general than I originally wrote
  guardR                  :: (MonadReader r m, Eq v)
                          => (r -> v)                -- value selector
                          -> v                       -- expected value
                          -> (v -> v -> m a)         -- error reporter
                          -> m a                     -- continuation (hush)
                          -> m a
  guardR sel val err good =  do
    v <- asks sel
    if v == val then good else err v val
  
  -- this is kinda dumb
  fi       :: Bool -> a -> a -> a
  fi p n y =  if p then y else n -- flip (if' p), if that existed
  
  -- verify we have the expected word size
  guardSize      :: Int -> Decoder Bool -> Decoder Bool
  -- see XSync documentation for this insanity
  guardSize 64 =  guardR width 32 propSizeErr . guardSize' 8         propShortErr
  guardSize  w =  guardR width  w propSizeErr . guardSize' (bytes w) propShortErr
  
  guardSize'       :: Int -> Decoder a -> Decoder a -> Decoder a
  guardSize' l n y =  gets value >>= \vs -> fi (length vs >= l) n y
  
  -- verify we have the expected property type
  guardType    :: Atom -> Decoder Bool -> Decoder Bool
  guardType  t =  guardR pType t propTypeErr
  
  -- dump a structure as a named tuple
  dumpList       :: [(String,Decoder Bool)] -> Decoder Bool
  dumpList proto =  do
    a <- asks pType
    dumpList'' (maxBound :: CULong) (map (\(s,d) -> (s,d,a)) proto) "("
  
  -- same but elements have their own distinct types
  dumpList'       :: [(String,Decoder Bool,Atom)] -> Decoder Bool
  dumpList' proto =  dumpList'' (maxBound :: CULong) proto "("
  
  -- same but only dump elements identified by provided mask
  dumpListByMask     :: CULong -> [(String,Decoder Bool)] -> Decoder Bool
  dumpListByMask m p =  do
    a <- asks pType
    dumpList'' m (map (\(s,d) -> (s,d,a)) p) "("
  
  -- and the previous two combined
  dumpListByMask'     :: CULong -> [(String,Decoder Bool,Atom)] -> Decoder Bool
  dumpListByMask' m p =  dumpList'' m p "("
  
  dumpList''                    :: CULong -> [(String,Decoder Bool,Atom)] -> String -> Decoder Bool
  dumpList'' _ []           _   =  append ")" >> return True
  dumpList'' 0 _            _   =  append ")" >> return True
  dumpList'' m ((l,p,t):ps) sep = do
    (e,sep') <- if m .&. 1 == 0
                then do
                  -- @@@ ew
                  st <- get
                  e <- local (\r -> r {pType = t}) p
                  v' <- gets value
                  put $ st {value = v'}
                  return (e,sep)
                else do
                  let label = sep ++ l ++ " = "
                  append label
                  e <- withJoint "" $ do
                         local (\r -> r {pType  = t
                                        ,indent = indent r + length label
                                        })
                               p
                  return (e,",")
    if e then dumpList'' (m `shiftR` 1) ps sep' else return e
  
  -- do the getTextProperty dance, the hard way.
  -- @@@ @COMPOUND_TEXT@ not supported yet.
  dumpString :: Decoder Bool
  dumpString =  do
    fmt <- asks pType
    [cOMPOUND_TEXT,uTF8_STRING] <- inX $ mapM getAtom ["COMPOUND_TEXT","UTF8_STRING"]
    case () of
      () | fmt == cOMPOUND_TEXT -> guardSize 16 (...)
         | fmt == sTRING        -> guardSize  8 $ do
                                     vs <- gets value
                                     modify (\r -> r {value = []})
                                     let ss = flip unfoldr (map twiddle vs) $
                                              \s -> if null s
                                                    then Nothing
                                                    else let (w,s'') = break (== '\NUL') s
                                                             s'      = if null s''
                                                                       then s''
                                                                       else tail s''
                                                          in Just (w,s')
                                     case ss of
                                       [s] -> append $ show s
                                       ss' -> let go (s:ss'') c = append c        >>
                                                                  append (show s) >>
                                                                  go ss'' ","
                                                  go []       _ = append "]"
                                               in append "[" >> go ss' ""
         | fmt == uTF8_STRING   -> dumpUTF -- duplicate type test instead of code :)
         | otherwise            -> (inX $ atomName fmt) >>=
                                   failure . ("unrecognized string type " ++)
  
  -- show who owns a selection
  dumpSelection :: Decoder Bool
  dumpSelection =  do
    -- system selections contain a window ID; others are random
    -- note that the window ID will be the same as the owner, so
    -- we don't really care anyway.  we *do* want the selection owner
    a <- asks property
    owner <- inX $ withDisplay $ \d -> io $ xGetSelectionOwner d a
    if owner == none
      then append "unowned"
      else do
        w <- inX $ debugWindow owner
        append $ "owned by " ++ w
  
  -- for now, not querying Xkb
  dumpXKlInds :: Decoder Bool
  dumpXKlInds =  guardType iNTEGER $ do
                   n <- fmap fromIntegral `fmap` getInt' 32
                   case n of
                     Nothing -> propShortErr
                     Just is -> append $ "indicators " ++ unwords (dumpInds is 1 1 [])
    where
      dumpInds                               :: Word32 -> Word32 -> Int -> [String] -> [String]
      dumpInds n bt c bs | n == 0 && c == 1 =  ["none"]
                         | n == 0           =  bs
                         | n .&. bt /= 0    =  dumpInds (n .&. complement bt)
                                                        (bt `shiftL` 1)
                                                        (c + 1)
                                                        ((show c):bs)
                         | otherwise        =  dumpInds n
                                                        (bt `shiftL` 1)
                                                        (c + 1)
                                                        bs
  
  -- decode an Atom
  dumpAtom :: Decoder Bool
  dumpAtom =
    guardType aTOM $ do
    a <- getInt' 32
    case a of
      Nothing -> return False
      Just a' -> do
             an <- inX $ atomName $ fromIntegral a'
             append an
  
  dumpWindow :: Decoder Bool
  dumpWindow =  guardSize 32 $ guardType wINDOW $ do
                  w <- getInt' 32
                  case w of
                    Nothing -> return False
                    Just w' -> inX (debugWindow (fromIntegral w')) >>= append
  
  -- a bit of a hack; as a Property it's a wINDOW, as a ClientMessage it's a list
  dumpActiveWindow :: Decoder Bool
  dumpActiveWindow =  guardSize 32 $ do
                        t <- asks pType
                        nAW <- inX $ getAtom "_NET_ACTIVE_WINDOW"
                        case () of
                          () | t == wINDOW -> dumpWindow
                             | t == nAW    -> dumpList' [("source"       ,dumpEnum awSource,cARDINAL)
                                                        ,("timestamp"    ,dumpTime         ,cARDINAL)
                                                        ,("active window",dumpWindow       ,wINDOW  )
                                                        ]
                          _                -> do
                                       t' <- inX $ atomName t
                                       failure $ concat ["(bad type "
                                                        ,t'
                                                        ,"; expected WINDOW or _NET_ACTIVE_WINDOW"
                                                        ]
  -- dump a generic CARDINAL value
  dumpInt   :: Int -> Decoder Bool
  dumpInt w =  guardSize w $ guardType cARDINAL $ getInt w show
  
  -- INTEGER is the signed version of CARDINAL
  dumpInteger   :: Int -> Decoder Bool
  dumpInteger w =  guardSize w $ guardType iNTEGER $ getInt w (show . signed w)
  
  -- reinterpret an unsigned as a signed
  signed     :: Int -> Integer -> Integer
  signed w i =  bit (w + 1) - i
  
  -- and wrappers to keep the parse list in bounds
  dump64 :: Decoder Bool
  dump64 =  dumpInt 64
  
  dump32 :: Decoder Bool
  dump32 =  dumpInt 32
  
  {- not used in standard properties
  dump16 :: Decoder Bool
  dump16 =  dumpInt 16
  -}
  
  dump8 :: Decoder Bool
  dump8 =  dumpInt 8
  
  -- I am assuming for the moment that this is a single string.
  -- This might be false; consider the way the STRING properties
  -- handle lists.
  dumpUTF :: Decoder Bool
  dumpUTF =  do
    uTF8_STRING <- inX $ getAtom "UTF8_STRING"
    guardType uTF8_STRING $ guardSize 8 $ do
    s <- gets value
    modify (\r -> r {value = []})
    append . show . decode . map fromIntegral $ s
    return True
  
  -- dump an enumerated value using a translation table
  dumpEnum'        :: [String] -> Atom -> Decoder Bool
  dumpEnum' ss fmt =  guardType fmt $
                      getInt 32     $
                      \r -> case () of
                              () | r < 0                 -> "undefined value " ++ show r
                                 | r >= genericLength ss -> "undefined value " ++ show r
                                 | otherwise             -> genericIndex ss r
  
  -- we do not, unlike @xev@, try to ascii-art pixmaps.
  dumpPixmap :: Decoder Bool
  dumpPixmap =  guardType pIXMAP $ do
                  p' <- getInt' 32
                  case p' of
                    Nothing -> return False
                    Just p  -> do
                      append $ "pixmap " ++ showHex p ""
                      g' <- inX $ withDisplay $ \d -> io $
                              Just `fmap` getGeometry d (fromIntegral p)
                              `E.catch`
                              \e -> case fromException e of
                                      Just x -> throw e `const` (x `asTypeOf` ExitSuccess)
                                      _      -> return Nothing
                      case g' of
                        Nothing                   -> append " (deleted)"
                        Just (_,x,y,wid,ht,bw,dp) ->
                            append $ concat
                                       [" ("
                                       ,show wid
                                       ,'x':show ht
                                       ,'x':show dp
                                       ,')':if bw == 0 then "" else '+':show bw
                                       ,"@("
                                       ,show x
                                       ,',':show y
                                       ,")"
                                       ]
  
  dumpOLAttrs :: Decoder Bool
  dumpOLAttrs = do
    pt <- inX $ getAtom "_OL_WIN_ATTR"
    guardType pt $ do
      msk <- getInt' 32
      case msk of
        Nothing   -> propShortErr
        Just msk' -> dumpListByMask (fromIntegral msk') [("window type" ,dumpAtom     )
                                                        ,("menu"        ,dump32       ) -- @@@ unk
                                                        ,("pushpin"     ,dumpEnum bool)
                                                        ,("limited menu",dump32       ) -- @@@ unk
                                                        ]
  
  dumpMwmHints :: Decoder Bool
  dumpMwmHints =  do
    ta <- asks property
    guardType ta $ do
      msk <- getInt' 32
      case msk of
        Nothing   -> propShortErr
        Just msk' -> dumpListByMask (fromIntegral msk') [("functions"  ,dumpBits mwmFuncs    )
                                                        ,("decorations",dumpBits mwmDecos    )
                                                        ,("input mode" ,dumpEnum mwmInputMode)
                                                        ,("status"     ,dumpBits mwmState    )
                                                        ]
  
  dumpMwmInfo :: Decoder Bool
  dumpMwmInfo =  do
    ta <- asks property
    guardType ta $ dumpList' [("flags" ,dumpBits mwmHints,cARDINAL)
                             ,("window",dumpWindow       ,wINDOW  )
                             ]
               
  -- the most common case
  dumpEnum    :: [String] -> Decoder Bool
  dumpEnum ss =  dumpEnum' ss cARDINAL
  
  -- implement exceptional cases atop a normal dumper
  -- @@@ there's gotta be a better way
  dumpExcept           :: [(Integer,String)] -> Decoder Bool -> Decoder Bool
  dumpExcept xs item = do
    -- this horror brought to you by reparsing to get the right value for our use
    sp <- get
    rc <- item
    if not rc then return False else do
      that <- get -- if none match then we just restore the value parse
      vs <- gets value
      let w = (length (value sp) - length vs) * 8
      -- now we get to reparse again so we get our copy of it
      put sp
      Just v <- getInt' w
      -- and after all that, we can process the exception list
      dumpExcept' xs that v
  
  dumpExcept'                                      :: [(Integer,String)]
                                                   -> DecodeState
                                                   -> Integer
                                                   -> Decoder Bool
  dumpExcept' []             that _                =  put that >> return True
  dumpExcept' ((exc,str):xs) that val | exc == val =  append str
                                      | otherwise  =  dumpExcept' xs that val
  
  -- use @ps@ to get process information.
  -- @@@@ assumes a POSIX @ps@, not a BSDish one.
  dumpPid :: Decoder Bool
  dumpPid =  guardType cARDINAL $ do
               n <- getInt' 32
               case n of
                 Nothing   -> return False
                 Just pid' -> do
                        let pid = show pid'
                            ps  = (proc "/bin/ps" ["-fp" ++ pid]) {std_out = CreatePipe}
                        (_,o,_,_) <- io $ createProcess ps
                        case o of
                          Nothing -> append $ "pid " ++ pid
                          Just p' -> do
                                    prc <- io $ lines `fmap` hGetContents p'
                                    -- deliberately forcing it
                                    append $ if length prc < 2
                                             then "pid " ++ pid
                                             else prc !! 1
  
  dumpTime :: Decoder Bool
  dumpTime =  append "server event # " >> dump32
  
  dumpState :: Decoder Bool
  dumpState =  do
    wM_STATE <- inX $ getAtom "WM_STATE"
    guardType wM_STATE $ dumpList' [("state"      ,dumpEnum wmState,cARDINAL)
                                   ,("icon window",dumpWindow      ,wINDOW  )
                                   ]
  
  dumpMotifDragReceiver :: Decoder Bool
  dumpMotifDragReceiver =  do
    ta <- inX $ getAtom "_MOTIF_DRAG_RECEIVER_INFO"
    guardType ta $ dumpList' [("endian"    ,dumpMotifEndian,cARDINAL)
                             ,("version"   ,dump8          ,cARDINAL)
                             ,("style"     ,dumpMDropStyle ,cARDINAL) -- @@@ dummy
                             ]
  
  dumpMDropStyle :: Decoder Bool
  dumpMDropStyle =  do
    d <- getInt' 8
    pad 1 $ case d of
              Nothing             -> propShortErr
              Just ps | ps == 0   -> pad 12 $ append "none"
                      | ps == 1   -> pad 12 $ append "drop only"
                      | ps == 2   ->          append "prefer preregister " >> dumpMDPrereg
                      | ps == 3   ->          append "preregister "        >> dumpMDPrereg
                      | ps == 4   -> pad 12 $ append "prefer dynamic"
                      | ps == 5   -> pad 12 $ append "dynamic"
                      | ps == 6   -> pad 12 $ append "prefer receiver"
                      | otherwise -> failure $ "unknown drop style " ++ show ps
  
  dumpMDPrereg :: Decoder Bool
  dumpMDPrereg =  do
    -- this is a bit ugly; we pretend to be extending the above dumpList'
    append ","
    append "proxy window = "
    withIndent 15 dumpWindow
    append ","
    append "drop sites = "
    dsc' <- getInt' 16
    case dsc' of
      Nothing  -> propShortErr
      Just dsc -> do
        withIndent 13 $ append (show dsc)
        pad 2 $ do
          append ","
          append "total size = "
          withIndent 13 dump32
          dumpMDBlocks $ fromIntegral dsc
      
  dumpMDBlocks   :: Int -> Decoder Bool
  dumpMDBlocks _ =  propSimple "(drop site info)" -- @@@ maybe later if needed
  
  dumpMotifEndian :: Decoder Bool
  dumpMotifEndian =  guardType cARDINAL $ guardSize 8 $ do
    c <- map twiddle `fmap` eat 1
    case c of
      ['l'] -> append "little"
      ['B'] -> append "big"
      _     -> failure "bad endian flag"
  
  pad     :: Int -> Decoder Bool -> Decoder Bool
  pad n p =  do
    vs <- gets value
    if length vs < n
      then propShortErr
      else modify (\r -> r {value = drop n vs}) >> p
  
  dumpPercent :: Decoder Bool
  dumpPercent =  guardType cARDINAL $ do
                   n <- getInt' 32
                   case n of
                     Nothing -> return False
                     Just n' -> 
                         let pct = 100 * fromIntegral n' / fromIntegral (maxBound :: Word32)
                             pct :: Double
                          in append $ show (round pct :: Integer) ++ "%"
  
  dumpWmHints :: Decoder Bool
  dumpWmHints =
    guardType wM_HINTS $ do
    msk <- getInt' 32
    case msk of
      Nothing   -> return False
      Just msk' -> dumpListByMask' (fromIntegral msk')
                                   [("input"        ,dumpEnum bool   ,cARDINAL)
                                   ,("initial_state",dumpEnum wmState,cARDINAL)
                                   ,("icon_pixmap"  ,dumpPixmap      ,pIXMAP  )
                                   ,("icon_window"  ,dumpWindow      ,wINDOW  )
                                   ,("icon_x"       ,dump32          ,cARDINAL)
                                   ,("icon_y"       ,dump32          ,cARDINAL)
                                   ,("icon_mask"    ,dumpPixmap      ,pIXMAP  )
                                   ,("window_group" ,dumpWindow      ,wINDOW  )
                                   ]
  
  dumpBits    :: [String] -> Decoder Bool
  dumpBits bs =  guardType cARDINAL $ do
                   n <- getInt' 32
                   case n of
                     Nothing -> return False
                     Just n' -> dumpBits' bs 1 (fromIntegral n') ""
  
  dumpBits' :: [String] -> Int -> Int -> String -> Decoder Bool
  dumpBits' []     _ n p = if n == 0 then return True else append (p ++ show n)
  dumpBits' (s:ss) b n p = do
    p' <- if n .&. b /= 0
          then append (p ++ s) >> return "|"
          else return p
    dumpBits' ss (b `shiftL` 1) (n .&. complement b) p'
  
  -- enum definitions --
  
  mwmFuncs :: [String]
  mwmFuncs =  ["all except"
              ,"resize"
              ,"move"
              ,"minimize"
              ,"maximize"
              ,"close"
              ]
  
  mwmDecos :: [String]
  mwmDecos =  ["all except"
              ,"border"
              ,"resize handle"
              ,"title"
              ,"menu button"
              ,"maximize button"
              ,"minimize button"
              ]
  
  mwmInputMode :: [String]
  mwmInputMode =  ["modeless"
                  ,"application modal"
                  ,"system model"
                  ,"full application modal"
                  ]
  
  mwmState :: [String]
  mwmState =  ["tearoff window"
              ]
  
  mwmHints :: [String]
  mwmHints =  ["standard startup"
              ,"custom startup"
              ]
  
  awSource :: [String]
  awSource =  ["unspecified"
              ,"application"
              ,"pager/task list"
              ]
  
  {- eventually...
  wmHintsFlags :: [String]
  wmHintsFlags =  ["Input"
                  ,"State"
                  ,"IconPixmap"
                  ,"IconWindow"
                  ,"IconX"
                  ,"IconY"
                  ,"IconMask"
                  ,"WindowGroup"
                  ]
  
  wmCRMask :: [String]
  wmCRMask =  ["X"
              ,"Y"
              ,"Width"
              ,"Height"
              ,"BorderWidth"
              ,"Sibling"
              ,"StackMode"
              ]
  -}
  
  wmPlacement :: [String]
  wmPlacement =  ["Above"
                 ,"Below"
                 ,"TopIf"
                 ,"BottomIf"
                 ,"Opposite"
                 ]
  
  bool :: [String]
  bool =  ["False","True"]
  
  nwmOrientation :: [String]
  nwmOrientation =  nwmEnum (Just "ORIENTATION") ["HORZ","VERT"]
  
  nwmOrigin :: [String]
  nwmOrigin =  nwmEnum Nothing ["TOPLEFT","TOPRIGHT","BOTTOMRIGHT","BOTTOMLEFT"]
  
  wmState :: [String]
  wmState =  ["Withdrawn","Normal","Zoomed (obsolete)","Iconified","Inactive"]
  
  nwmEnum                  :: Maybe String
                           -> [String]
                           -> [String]
  nwmEnum Nothing       vs =  map ( "_NET_WM_"                   ++) vs
  nwmEnum (Just prefix) vs =  map (("_NET_WM_" ++ prefix ++ "_") ++) vs
  
  -- and the lowest level coercions --
  
  -- parse and return an integral value
  getInt'    :: Int -> Decoder (Maybe Integer)
  -- see XSync documentation for this insanity
  getInt' 64 =  guardR width 32 (\a e -> propSizeErr a e >> return Nothing) $
                guardSize' 8 (propShortErr >> return Nothing) $ do
                  lo <- inhale 32
                  hi <- inhale 32
                  return $ Just $ lo + hi * (fromIntegral (maxBound :: Word32) + 1)
  getInt' w  =  guardR width w  (\a e -> propSizeErr a e >> return Nothing) $
                guardSize' (bytes w) (propShortErr >> return Nothing)       $
                Just `fmap` inhale w
  
  -- parse an integral value and feed it to a show-er of some kind
  getInt     :: Int -> (Integer -> String) -> Decoder Bool
  getInt w f =  getInt' w >>= maybe (return False) (append . f)
  
  -- bottommost level:  parse an integral value out of the stream.
  -- Not much in the way of error checking; it is assumed you used
  -- the appropriate guards.
  -- @@@@@@@@@ evil beyond evil.  there *has* to be a better way
  inhale    :: Int -> Decoder Integer
  inhale  8 =  do
                 [b] <- eat 1
                 return $ fromIntegral b
  inhale 16 =  do
                 [b0,b1] <- eat 2
                 io $ allocaArray 2 $ \p -> do
                   pokeArray p [b0,b1]
                   [v] <- peekArray 1 (castPtr p :: Ptr Word16)
                   return $ fromIntegral v
  inhale 32 =  do
                 [b0,b1,b2,b3] <- eat 4
                 io $ allocaArray 4 $ \p -> do
                   pokeArray p [b0,b1,b2,b3]
                   [v] <- peekArray 1 (castPtr p :: Ptr Word32)
                   return $ fromIntegral v
  inhale  b =  error $ "inhale " ++ show b
  
  eat   :: Int -> Decoder Raw
  eat n =  do
    (bs,rest) <- splitAt n `fmap` gets value
    modify (\r -> r {value = rest})
    return bs
  
  -- actually do formatting type stuffs
  -- sorta stubbed for the moment
  -- eventually we should do indentation foo here
  append :: String -> Decoder Bool
  append =  append' True
  
  -- and the same but for errors
  failure :: String -> Decoder Bool
  failure =  append' False
  
  -- common appender
  append'     :: Bool -> String -> Decoder Bool
  append' b s =  do
    j <- gets joint
    modify (\r -> r {accum = accum r ++ j ++ s})
    return b
  
  -- consume all and output a constant string
  propSimple   :: String -> Decoder Bool
  propSimple s =  modify (\r -> r {value = []}) >> append s
  
  -- report various errors
  propShortErr :: Decoder Bool
  propShortErr =  failure "(property ended prematurely)"
  
  propSizeErr     :: Int -> Int -> Decoder Bool
  propSizeErr e a =  failure $ "(bad bit width " ++
                               show a            ++
                               "; expected "     ++
                               show e            ++
                               ")"
  
  propTypeErr     :: Atom -> Atom -> Decoder Bool
  propTypeErr a e =  do
    e' <- inX $ atomName e
    a' <- inX $ atomName a
    failure $ "(bad type " ++ a' ++"; expected " ++ e' ++ ")"
  
  -- for stubs
  (...) :: Decoder Bool
  (...) =  do
    fmt <- asks pType >>= inX . atomName
    propSimple $ "(unimplemented type " ++ fmt ++ ")"
  
  -- you like fi, I like this
  twiddle :: (Enum a, Enum b) => a -> b
  twiddle =  toEnum . fromEnum
  