    {-# LANGUAGE DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses, PatternGuards #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module       : XMonad.Layout.ToggleLayouts
    -- Copyright    : (c) David Roundy <droundy@darcs.net>
    -- License      : BSD
    --
    -- Maintainer   : none
    -- Stability    : unstable
    -- Portability  : portable
    --
    -- A module to toggle between two layouts.
    -----------------------------------------------------------------------------

    module XMonad.Layout.ToggleLayouts (
        -- * Usage
        -- $usage
        toggleLayouts, ToggleLayout(..), ToggleLayouts
        ) where

    import XMonad
    import XMonad.StackSet (Workspace (..))

    -- $usage
    -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
    --
    -- > import XMonad.Layout.ToggleLayouts
    --
    -- Then edit your @layoutHook@ by adding the ToggleLayouts layout:
    --
    -- > myLayout = toggleLayouts Full (Tall 1 (3/100) (1/2)) ||| etc..
    -- > main = xmonad def { layoutHook = myLayout }
    --
    -- For more detailed instructions on editing the layoutHook see:
    --
    -- "XMonad.Doc.Extending#Editing_the_layout_hook"
    --
    -- To toggle between layouts add a key binding like
    --
    -- >    , ((modm .|. controlMask, xK_space), sendMessage ToggleLayout)
    --
    -- or a key binding like
    --
    -- >    , ((modm .|. controlMask, xK_space), sendMessage (Toggle "Full"))
    --
    -- For detailed instruction on editing the key binding see:
    --
    -- "XMonad.Doc.Extending#Editing_key_bindings".

    data ToggleLayouts lt lf a = ToggleLayouts Bool (lt a) (lf a) deriving (ReadPrec [ToggleLayouts lt lf a]
    ReadPrec (ToggleLayouts lt lf a)
    Int -> ReadS (ToggleLayouts lt lf a)
    ReadS [ToggleLayouts lt lf a]
    (Int -> ReadS (ToggleLayouts lt lf a))
    -> ReadS [ToggleLayouts lt lf a]
    -> ReadPrec (ToggleLayouts lt lf a)
    -> ReadPrec [ToggleLayouts lt lf a]
    -> Read (ToggleLayouts lt lf a)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    ReadPrec [ToggleLayouts lt lf a]
    forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    ReadPrec (ToggleLayouts lt lf a)
    forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    Int -> ReadS (ToggleLayouts lt lf a)
    forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    ReadS [ToggleLayouts lt lf a]
    readListPrec :: ReadPrec [ToggleLayouts lt lf a]
    $creadListPrec :: forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    ReadPrec [ToggleLayouts lt lf a]
    readPrec :: ReadPrec (ToggleLayouts lt lf a)
    $creadPrec :: forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    ReadPrec (ToggleLayouts lt lf a)
    readList :: ReadS [ToggleLayouts lt lf a]
    $creadList :: forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    ReadS [ToggleLayouts lt lf a]
    readsPrec :: Int -> ReadS (ToggleLayouts lt lf a)
    $creadsPrec :: forall (lt :: * -> *) (lf :: * -> *) a.
    (Read (lt a), Read (lf a)) =>
    Int -> ReadS (ToggleLayouts lt lf a)
    Read,Int -> ToggleLayouts lt lf a -> ShowS
    [ToggleLayouts lt lf a] -> ShowS
    ToggleLayouts lt lf a -> String
    (Int -> ToggleLayouts lt lf a -> ShowS)
    -> (ToggleLayouts lt lf a -> String)
    -> ([ToggleLayouts lt lf a] -> ShowS)
    -> Show (ToggleLayouts lt lf a)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall (lt :: * -> *) (lf :: * -> *) a.
    (Show (lt a), Show (lf a)) =>
    Int -> ToggleLayouts lt lf a -> ShowS
    forall (lt :: * -> *) (lf :: * -> *) a.
    (Show (lt a), Show (lf a)) =>
    [ToggleLayouts lt lf a] -> ShowS
    forall (lt :: * -> *) (lf :: * -> *) a.
    (Show (lt a), Show (lf a)) =>
    ToggleLayouts lt lf a -> String
    showList :: [ToggleLayouts lt lf a] -> ShowS
    $cshowList :: forall (lt :: * -> *) (lf :: * -> *) a.
    (Show (lt a), Show (lf a)) =>
    [ToggleLayouts lt lf a] -> ShowS
    show :: ToggleLayouts lt lf a -> String
    $cshow :: forall (lt :: * -> *) (lf :: * -> *) a.
    (Show (lt a), Show (lf a)) =>
    ToggleLayouts lt lf a -> String
    showsPrec :: Int -> ToggleLayouts lt lf a -> ShowS
    $cshowsPrec :: forall (lt :: * -> *) (lf :: * -> *) a.
    (Show (lt a), Show (lf a)) =>
    Int -> ToggleLayouts lt lf a -> ShowS
    Show)
    data ToggleLayout = ToggleLayout | Toggle String deriving (ReadPrec [ToggleLayout]
    ReadPrec ToggleLayout
    Int -> ReadS ToggleLayout
    ReadS [ToggleLayout]
    (Int -> ReadS ToggleLayout)
    -> ReadS [ToggleLayout]
    -> ReadPrec ToggleLayout
    -> ReadPrec [ToggleLayout]
    -> Read ToggleLayout
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [ToggleLayout]
    $creadListPrec :: ReadPrec [ToggleLayout]
    readPrec :: ReadPrec ToggleLayout
    $creadPrec :: ReadPrec ToggleLayout
    readList :: ReadS [ToggleLayout]
    $creadList :: ReadS [ToggleLayout]
    readsPrec :: Int -> ReadS ToggleLayout
    $creadsPrec :: Int -> ReadS ToggleLayout
    Read,Int -> ToggleLayout -> ShowS
    [ToggleLayout] -> ShowS
    ToggleLayout -> String
    (Int -> ToggleLayout -> ShowS)
    -> (ToggleLayout -> String)
    -> ([ToggleLayout] -> ShowS)
    -> Show ToggleLayout
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ToggleLayout] -> ShowS
    $cshowList :: [ToggleLayout] -> ShowS
    show :: ToggleLayout -> String
    $cshow :: ToggleLayout -> String
    showsPrec :: Int -> ToggleLayout -> ShowS
    $cshowsPrec :: Int -> ToggleLayout -> ShowS
    Show,Typeable)
    instance Message ToggleLayout

    toggleLayouts :: (LayoutClass lt a, LayoutClass lf a) => lt a -> lf a -> ToggleLayouts lt lf a
    toggleLayouts :: lt a -> lf a -> ToggleLayouts lt lf a
    toggleLayouts = Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    False

    instance (LayoutClass lt a, LayoutClass lf a) => LayoutClass (ToggleLayouts lt lf) a where
        runLayout :: Workspace String (ToggleLayouts lt lf a) a
    -> Rectangle -> X ([(a, Rectangle)], Maybe (ToggleLayouts lt lf a))
    runLayout (Workspace i :: String
    i (ToggleLayouts True lt :: lt a
    lt lf :: lf a
    lf) ms :: Maybe (Stack a)
    ms) r :: Rectangle
    r = do (ws :: [(a, Rectangle)]
    ws,mlt' :: Maybe (lt a)
    mlt') <- Workspace String (lt a) a
    -> Rectangle -> X ([(a, Rectangle)], Maybe (lt a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    Workspace String (layout a) a
    -> Rectangle -> X ([(a, Rectangle)], Maybe (layout a))
    runLayout (String -> lt a -> Maybe (Stack a) -> Workspace String (lt a) a
    forall i l a. i -> l -> Maybe (Stack a) -> Workspace i l a
    Workspace String
    i lt a
    lt Maybe (Stack a)
    ms) Rectangle
    r
                                                                     ([(a, Rectangle)], Maybe (ToggleLayouts lt lf a))
    -> X ([(a, Rectangle)], Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([(a, Rectangle)]
    ws,(lt a -> ToggleLayouts lt lf a)
    -> Maybe (lt a) -> Maybe (ToggleLayouts lt lf a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\lt' :: lt a
    lt' -> Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    True lt a
    lt' lf a
    lf) Maybe (lt a)
    mlt')

        runLayout (Workspace i :: String
    i (ToggleLayouts False lt :: lt a
    lt lf :: lf a
    lf) ms :: Maybe (Stack a)
    ms) r :: Rectangle
    r = do (ws :: [(a, Rectangle)]
    ws,mlf' :: Maybe (lf a)
    mlf') <- Workspace String (lf a) a
    -> Rectangle -> X ([(a, Rectangle)], Maybe (lf a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    Workspace String (layout a) a
    -> Rectangle -> X ([(a, Rectangle)], Maybe (layout a))
    runLayout (String -> lf a -> Maybe (Stack a) -> Workspace String (lf a) a
    forall i l a. i -> l -> Maybe (Stack a) -> Workspace i l a
    Workspace String
    i lf a
    lf Maybe (Stack a)
    ms) Rectangle
    r
                                                                      ([(a, Rectangle)], Maybe (ToggleLayouts lt lf a))
    -> X ([(a, Rectangle)], Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([(a, Rectangle)]
    ws,(lf a -> ToggleLayouts lt lf a)
    -> Maybe (lf a) -> Maybe (ToggleLayouts lt lf a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\lf' :: lf a
    lf' -> Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    False lt a
    lt lf a
    lf') Maybe (lf a)
    mlf')
        description :: ToggleLayouts lt lf a -> String
    description (ToggleLayouts True lt :: lt a
    lt _) = lt a -> String
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> String
    description lt a
    lt
        description (ToggleLayouts False _ lf :: lf a
    lf) = lf a -> String
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> String
    description lf a
    lf
        handleMessage :: ToggleLayouts lt lf a
    -> SomeMessage -> X (Maybe (ToggleLayouts lt lf a))
    handleMessage (ToggleLayouts bool :: Bool
    bool lt :: lt a
    lt lf :: lf a
    lf) m :: SomeMessage
    m
            | Just ReleaseResources <- SomeMessage -> Maybe LayoutMessages
    forall m. Message m => SomeMessage -> Maybe m
    fromMessage SomeMessage
    m =
                                       do Maybe (lf a)
    mlf' <- lf a -> SomeMessage -> X (Maybe (lf a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lf a
    lf SomeMessage
    m
                                          Maybe (lt a)
    mlt' <- lt a -> SomeMessage -> X (Maybe (lt a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lt a
    lt SomeMessage
    m
                                          Maybe (ToggleLayouts lt lf a) -> X (Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (ToggleLayouts lt lf a)
     -> X (Maybe (ToggleLayouts lt lf a)))
    -> Maybe (ToggleLayouts lt lf a)
    -> X (Maybe (ToggleLayouts lt lf a))
    forall a b. (a -> b) -> a -> b
    $ case (Maybe (lt a)
    mlt',Maybe (lf a)
    mlf') of
                                              (Nothing ,Nothing ) -> Maybe (ToggleLayouts lt lf a)
    forall a. Maybe a
    Nothing
                                              (Just lt' :: lt a
    lt',Nothing ) -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a. a -> Maybe a
    Just (ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a))
    -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a b. (a -> b) -> a -> b
    $ Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    bool lt a
    lt' lf a
    lf
                                              (Nothing ,Just lf' :: lf a
    lf') -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a. a -> Maybe a
    Just (ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a))
    -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a b. (a -> b) -> a -> b
    $ Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    bool lt a
    lt lf a
    lf'
                                              (Just lt' :: lt a
    lt',Just lf' :: lf a
    lf') -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a. a -> Maybe a
    Just (ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a))
    -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a b. (a -> b) -> a -> b
    $ Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    bool lt a
    lt' lf a
    lf'
        handleMessage (ToggleLayouts True lt :: lt a
    lt lf :: lf a
    lf) m :: SomeMessage
    m
            | Just ToggleLayout <- SomeMessage -> Maybe ToggleLayout
    forall m. Message m => SomeMessage -> Maybe m
    fromMessage SomeMessage
    m = do Maybe (lt a)
    mlt' <- lt a -> SomeMessage -> X (Maybe (lt a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lt a
    lt (LayoutMessages -> SomeMessage
    forall a. Message a => a -> SomeMessage
    SomeMessage LayoutMessages
    Hide)
                                                      let lt' :: lt a
    lt' = lt a -> (lt a -> lt a) -> Maybe (lt a) -> lt a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe lt a
    lt lt a -> lt a
    forall a. a -> a
    id Maybe (lt a)
    mlt'
                                                      Maybe (ToggleLayouts lt lf a) -> X (Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (ToggleLayouts lt lf a)
     -> X (Maybe (ToggleLayouts lt lf a)))
    -> Maybe (ToggleLayouts lt lf a)
    -> X (Maybe (ToggleLayouts lt lf a))
    forall a b. (a -> b) -> a -> b
    $ ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a. a -> Maybe a
    Just (ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a))
    -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a b. (a -> b) -> a -> b
    $ Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    False lt a
    lt' lf a
    lf
            | Just (Toggle d :: String
    d) <- SomeMessage -> Maybe ToggleLayout
    forall m. Message m => SomeMessage -> Maybe m
    fromMessage SomeMessage
    m,
              String
    d String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == lt a -> String
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> String
    description lt a
    lt Bool -> Bool -> Bool
    || String
    d String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == lf a -> String
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> String
    description lf a
    lf =
                  do Maybe (lt a)
    mlt' <- lt a -> SomeMessage -> X (Maybe (lt a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lt a
    lt (LayoutMessages -> SomeMessage
    forall a. Message a => a -> SomeMessage
    SomeMessage LayoutMessages
    Hide)
                     let lt' :: lt a
    lt' = lt a -> (lt a -> lt a) -> Maybe (lt a) -> lt a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe lt a
    lt lt a -> lt a
    forall a. a -> a
    id Maybe (lt a)
    mlt'
                     Maybe (ToggleLayouts lt lf a) -> X (Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (ToggleLayouts lt lf a)
     -> X (Maybe (ToggleLayouts lt lf a)))
    -> Maybe (ToggleLayouts lt lf a)
    -> X (Maybe (ToggleLayouts lt lf a))
    forall a b. (a -> b) -> a -> b
    $ ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a. a -> Maybe a
    Just (ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a))
    -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a b. (a -> b) -> a -> b
    $ Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    False lt a
    lt' lf a
    lf
            | Bool
    otherwise = do Maybe (lt a)
    mlt' <- lt a -> SomeMessage -> X (Maybe (lt a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lt a
    lt SomeMessage
    m
                             Maybe (ToggleLayouts lt lf a) -> X (Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (ToggleLayouts lt lf a)
     -> X (Maybe (ToggleLayouts lt lf a)))
    -> Maybe (ToggleLayouts lt lf a)
    -> X (Maybe (ToggleLayouts lt lf a))
    forall a b. (a -> b) -> a -> b
    $ (lt a -> ToggleLayouts lt lf a)
    -> Maybe (lt a) -> Maybe (ToggleLayouts lt lf a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\lt' :: lt a
    lt' -> Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    True lt a
    lt' lf a
    lf) Maybe (lt a)
    mlt'
        handleMessage (ToggleLayouts False lt :: lt a
    lt lf :: lf a
    lf) m :: SomeMessage
    m
            | Just ToggleLayout <- SomeMessage -> Maybe ToggleLayout
    forall m. Message m => SomeMessage -> Maybe m
    fromMessage SomeMessage
    m = do Maybe (lf a)
    mlf' <- lf a -> SomeMessage -> X (Maybe (lf a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lf a
    lf (LayoutMessages -> SomeMessage
    forall a. Message a => a -> SomeMessage
    SomeMessage LayoutMessages
    Hide)
                                                      let lf' :: lf a
    lf' = lf a -> (lf a -> lf a) -> Maybe (lf a) -> lf a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe lf a
    lf lf a -> lf a
    forall a. a -> a
    id Maybe (lf a)
    mlf'
                                                      Maybe (ToggleLayouts lt lf a) -> X (Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (ToggleLayouts lt lf a)
     -> X (Maybe (ToggleLayouts lt lf a)))
    -> Maybe (ToggleLayouts lt lf a)
    -> X (Maybe (ToggleLayouts lt lf a))
    forall a b. (a -> b) -> a -> b
    $ ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a. a -> Maybe a
    Just (ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a))
    -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a b. (a -> b) -> a -> b
    $ Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    True lt a
    lt lf a
    lf'
            | Just (Toggle d :: String
    d) <- SomeMessage -> Maybe ToggleLayout
    forall m. Message m => SomeMessage -> Maybe m
    fromMessage SomeMessage
    m,
              String
    d String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == lt a -> String
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> String
    description lt a
    lt Bool -> Bool -> Bool
    || String
    d String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == lf a -> String
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> String
    description lf a
    lf =
                  do Maybe (lf a)
    mlf' <- lf a -> SomeMessage -> X (Maybe (lf a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lf a
    lf (LayoutMessages -> SomeMessage
    forall a. Message a => a -> SomeMessage
    SomeMessage LayoutMessages
    Hide)
                     let lf' :: lf a
    lf' = lf a -> (lf a -> lf a) -> Maybe (lf a) -> lf a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe lf a
    lf lf a -> lf a
    forall a. a -> a
    id Maybe (lf a)
    mlf'
                     Maybe (ToggleLayouts lt lf a) -> X (Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (ToggleLayouts lt lf a)
     -> X (Maybe (ToggleLayouts lt lf a)))
    -> Maybe (ToggleLayouts lt lf a)
    -> X (Maybe (ToggleLayouts lt lf a))
    forall a b. (a -> b) -> a -> b
    $ ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a. a -> Maybe a
    Just (ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a))
    -> ToggleLayouts lt lf a -> Maybe (ToggleLayouts lt lf a)
    forall a b. (a -> b) -> a -> b
    $ Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    True lt a
    lt lf a
    lf'
            | Bool
    otherwise = do Maybe (lf a)
    mlf' <- lf a -> SomeMessage -> X (Maybe (lf a))
    forall (layout :: * -> *) a.
    LayoutClass layout a =>
    layout a -> SomeMessage -> X (Maybe (layout a))
    handleMessage lf a
    lf SomeMessage
    m
                             Maybe (ToggleLayouts lt lf a) -> X (Maybe (ToggleLayouts lt lf a))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (ToggleLayouts lt lf a)
     -> X (Maybe (ToggleLayouts lt lf a)))
    -> Maybe (ToggleLayouts lt lf a)
    -> X (Maybe (ToggleLayouts lt lf a))
    forall a b. (a -> b) -> a -> b
    $ (lf a -> ToggleLayouts lt lf a)
    -> Maybe (lf a) -> Maybe (ToggleLayouts lt lf a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\lf' :: lf a
    lf' -> Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    forall (lt :: * -> *) (lf :: * -> *) a.
    Bool -> lt a -> lf a -> ToggleLayouts lt lf a
    ToggleLayouts Bool
    False lt a
    lt lf a
    lf') Maybe (lf a)
    mlf'