SwitchChannel,

    SelectChannel,

    let can_switch_channel = changed_files.is_empty();

    let has_other_channels = !other_channels.is_empty();

                can_switch_channel.then_some(Msg::SwitchChannel),

                has_other_channels.then_some(Msg::SelectChannel),

    let switch_channel =
        || action_button("c", "switch channel", Msg::SwitchChannel);

    let select_channel =
        || action_button("c", "select channel", Msg::SelectChannel);

    let confirm = || action_button("Enter", "confirm", Msg::Confirm);

    let confirm =
        |label: &'static str| action_button("Enter", label, Msg::Confirm);

            has_other_channels,

            let row = add_if(!can_record, switch_channel, row);

            let row = add_if(has_other_channels, select_channel, row);

            has_other_channels,

            let row = add_if(!can_record, switch_channel, row);

            let row = add_if(has_other_channels, select_channel, row);

        ActionState::Diff { can_record } => {

        ActionState::Diff {
            can_record,
            has_other_channels,
        } => {

            let row = add_if(!can_record, switch_channel, row);

            let row = add_if(has_other_channels, select_channel, row);

            SwitchingChannelState::SomethingSelected => {
                row([down(), up(), confirm(), cancel()])

            SwitchingChannelState::SomethingSelected { can_switch } => {
                let row = row([down(), up(), cancel()]);
                let row = add_if(can_switch, || confirm("switch channel"), row);
                row

            let row = add_if(!empty && unique, confirm, row);

            let row = add_if(!empty && unique, || confirm("confirm fork"), row);

        has_other_channels: bool,

        has_other_channels: bool,

        has_other_channels: bool,

    SomethingSelected,

    SomethingSelected { can_switch: bool },

            SwitchingChannelState::SomethingSelected

            let can_switch = repo.state.changed_files.is_empty();
            SwitchingChannelState::SomethingSelected { can_switch }

    let has_other_channels = !repo.state.other_channels.is_empty();

                    ActionState::Diff { can_record }

                    ActionState::Diff {
                        can_record,
                        has_other_channels,
                    }

                        has_other_channels,

                    has_other_channels,

                    ActionState::Diff { can_record }

                    ActionState::Diff {
                        can_record,
                        has_other_channels,
                    }

                        has_other_channels,

                    has_other_channels,

                        ActionState::Diff { can_record }

                        ActionState::Diff {
                            can_record,
                            has_other_channels,
                        }

                            has_other_channels,

                        has_other_channels,

                has_other_channels,

            has_other_channels,

                } else if let Some(name) = repo.forking_channel.take() {
                    if !repo.state.other_channels.contains(&name) {
                        state
                            .repo_tx_in
                            .send(repo::MsgIn::ForkChannel(name))
                            .unwrap();
                    }

                } else if let Some(name) =
                    repo.forking_channel.take_if(|name| {
                        let name = name.trim();
                        let empty = name.is_empty();
                        let unique = || {
                            !repo.state.other_channels.iter().any(|n| n == name)
                        };
                        !empty && unique()
                    })
                {
                    state
                        .repo_tx_in
                        .send(repo::MsgIn::ForkChannel(name))
                        .unwrap();

                } else if matches!(
                    repo.entire_log.as_ref(),
                    Some(app::EntireLog::Got { .. }),
                ) {
                    // Repeated match to take ownership of the log
                    if let Some(app::EntireLog::Got { log, nav }) =
                        repo.entire_log.take()
                    {
                        // Cache for later viewing
                        repo.entire_log =
                            Some(app::EntireLog::NotViewing { log, nav });
                    } else {
                        debug_assert!(false, "The outter match should have the same condition as the inner match)")
                    }

                } else if let Some(app::EntireLog::Got { log, nav }) = repo
                    .entire_log
                    .take_if(|log| matches!(log, app::EntireLog::Got { .. }))
                {
                    // Cache for later viewing
                    repo.entire_log =
                        Some(app::EntireLog::NotViewing { log, nav });

        app::Msg::SwitchChannel => {

        app::Msg::SelectChannel => {

                        if let Some(app::EntireLog::NotViewing { log, nav }) =

                        let Some(app::EntireLog::NotViewing { log, nav }) =

                        {
                            repo.entire_log =
                                Some(app::EntireLog::Got { log, nav });
                        } else {
                            debug_assert!(false, "The outter match should have the same condition as the inner match)")
                        }

                        else {
                            unreachable!()
                        };
                        repo.entire_log =
                            Some(app::EntireLog::Got { log, nav });

                    "c" => Some(Msg::View(app::Msg::SwitchChannel)),

                    "c" => Some(Msg::View(app::Msg::SelectChannel)),