anchor.diff:              return { model with Status = Some <| MainStatus.sort field desc }
           }
   
  -    let initModel (config: Config) (fsReader: IFileSystemReader) startOptions isFirstInstance model =
  -        let defaultPath = config.DefaultPath |> Path.Parse |? Path.Root
  -        let startPath =
  -            startOptions.StartPath |? (
  -                match config.StartPath with
  -                | RestorePrevious -> config.PreviousPath
  -                | DefaultPath -> config.DefaultPath
  -            )
  -        { loadConfig fsReader config model with
  -            Location =
  -                match config.StartPath with
  -                | RestorePrevious -> defaultPath
  -                | DefaultPath -> config.PreviousPath |> Path.Parse |? defaultPath
  -            WindowLocation =
  -                startOptions.StartLocation |> Option.defaultWith (fun () ->
  -                    if isFirstInstance then (config.Window.Left, config.Window.Top)
  -                    else (config.Window.Left + 30, config.Window.Top + 30))
  -            WindowSize = startOptions.StartSize |? (config.Window.Width, config.Window.Height)
  -        } |> Navigation.openUserPath fsReader startPath
  +        let toggleHidden fsReader model = result {
  +            let! model =
  +                { model with ShowHidden = not model.ShowHidden }
  +                |> openPath fsReader model.Location (SelectName model.SelectedNode.Name)
  +            return { model with Status = Some <| MainStatus.toggleHidden model.ShowHidden }
  +        }
   
       module Cursor =
           let private moveCursorToNext predicate reverse model =
  
positive.code:                 yield! Navigation.refresh fsReader model |> Result.map (performedAction action)
          }
  
  
  type MainController(fsReader: IFileSystemReader,
                      fsWriter: IFileSystemWriter,
  
negative.code:         | Back -> resultHandler (MainLogic.Navigation.back fsReader)
          | Forward -> resultHandler (MainLogic.Navigation.forward fsReader)
          | Refresh -> resultHandler (MainLogic.Navigation.refresh fsReader)
          | Undo -> asyncResultHandler (MainLogic.Action.undo fsReader fsWriter)
          | Redo -> asyncResultHandler (MainLogic.Action.redo fsReader fsWriter)
          | StartPrompt promptType -> resultHandler (MainLogic.Action.startInput fsReader (Prompt promptType))
          | StartConfirm confirmType -> resultHandler (MainLogic.Action.startInput fsReader (Confirm confirmType))
          | StartInput inputType -> resultHandler (MainLogic.Action.startInput fsReader (Input inputType))
          | SubmitInput -> asyncResultHandler (MainLogic.submitInput fsReader fsWriter config)
          | InputCharTyped c -> asyncResultHandler (MainLogic.inputCharTyped fsReader fsWriter config c)
          | FindNext -> Sync <| MainLogic.toMutation MainLogic.Cursor.findNext
          | SearchNext -> Sync <| MainLogic.toMutation (MainLogic.Cursor.searchNext false)
          | SearchPrevious -> Sync <| MainLogic.toMutation (MainLogic.Cursor.searchNext true)
          | StartMove -> Sync <| MainLogic.toMutation (MainLogic.Action.registerItem Move)
          | StartCopy -> Sync <| MainLogic.toMutation (MainLogic.Action.registerItem Copy)
          | Put -> asyncResultHandler (MainLogic.Action.put fsReader fsWriter false)
          | Recycle -> asyncResultHandler (MainLogic.Action.recycle fsReader fsWriter config)
          | SortList field -> resultHandler (MainLogic.Navigation.sortList fsReader field)
          | ToggleHidden -> resultHandler (MainLogic.Navigation.toggleHidden fsReader)
          | OpenSplitScreenWindow -> resultHandler (MainLogic.Action.openSplitScreenWindow operatingSystem getScreenBounds)
          | OpenSettings -> resultHandler (MainLogic.Action.openSettings fsReader settingsFactory config)
          | OpenExplorer -> Sync <| MainLogic.toMutation (MainLogic.Action.openExplorer operatingSystem)
          | OpenCommandLine -> resultHandler (MainLogic.Action.openCommandLine operatingSystem config)
          | OpenWithTextEditor -> resultHandler (MainLogic.Action.openWithTextEditor operatingSystem config)
          | ConfigChanged -> Sync <| MainLogic.toMutation (MainLogic.loadConfig fsReader config)
          | Exit -> Sync (ignore >> closeWindow)
  
      member this.KeyPress dispatcher chord handleKey model = async {
          let event =
              if chord = (ModifierKeys.None, Key.Escape) then
                  handleKey ()
  