module Proteome.Add where

import qualified Data.Text as Text
import Path (Abs, Dir, Path, dirname, parent, stripProperPrefix)
import Path.IO (listDir)
import Ribosome (
  Bang (Bang),
  Handler,
  PluginName,
  Rpc,
  RpcError,
  SettingError,
  Settings,
  mapReport,
  pathText,
  resumeReport,
  )
import Ribosome.Menu (
  Filter (Fuzzy),
  MenuItem (..),
  MenuResult,
  MenuWidget,
  ModalState,
  ModalWindowMenus,
  modal,
  staticWindowMenu,
  traverseSelection_,
  )
import Ribosome.Scratch (scratch, syntax)
import qualified Ribosome.Settings as Settings

import Proteome.Add.Syntax (addSyntax)
import qualified Proteome.Data.AddError as AddError
import Proteome.Data.AddError (AddError)
import Proteome.Data.AddItem (AddItem (AddItem))
import Proteome.Data.AddOptions (AddOptions (AddOptions))
import Proteome.Data.Env (Env)
import Proteome.Data.Project (Project (Project))
import qualified Proteome.Data.ProjectConfig as ProjectConfig
import Proteome.Data.ProjectConfig (ProjectConfig)
import Proteome.Data.ProjectMetadata (ProjectMetadata (VirtualProject))
import Proteome.Data.ProjectName (ProjectName (ProjectName))
import Proteome.Data.ProjectType (ProjectType (ProjectType))
import Proteome.Data.ResolveError (ResolveError)
import Proteome.Path (dropSlash)
import Proteome.Project.Activate (selectProject)
import Proteome.Project.Resolve (fromNameSettings)
import qualified Proteome.Settings as Settings

type AddState =
  ModalState AddItem

add ::
  Members [Settings, Rpc, AtomicState Env, Reader PluginName, Stop ResolveError, Log, Embed IO] r =>
  ProjectName ->
  Maybe ProjectType ->
  Bool ->
  Sem r ()
add :: forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
ProjectName -> Maybe ProjectType -> Bool -> Sem r ()
add ProjectName
name Maybe ProjectType
tpe Bool
activate = do
  Project -> Sem r ()
forall {s} {r :: EffectRow} {a}.
(Member (AtomicState s) r, Monoid a, HasField' "projects" s a,
 IsList a, Item a ~ Project) =>
Project -> Sem r ()
addDirProject (Project -> Sem r ()) -> Sem r Project -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ProjectName -> Maybe ProjectType -> Sem r Project
forall (r :: EffectRow).
Members '[Settings, Stop ResolveError, Log, Embed IO] r =>
ProjectName -> Maybe ProjectType -> Sem r Project
fromNameSettings ProjectName
name Maybe ProjectType
tpe
  Bool -> Sem r () -> Sem r ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
activate (Int -> Sem r ()
forall (r :: EffectRow).
Members
  '[Settings, AtomicState Env, Reader PluginName, Rpc, Embed IO] r =>
Int -> Sem r ()
selectProject (-Int
1))
  where
    addDirProject :: Project -> Sem r ()
addDirProject (Project (VirtualProject ProjectName
_) [ProjectType]
_ Maybe ProjectLang
_ [ProjectLang]
_) =
      Sem r ()
forall (f :: * -> *). Applicative f => f ()
unit
    addDirProject Project
project =
      (s -> s) -> Sem r ()
forall s (r :: EffectRow).
Member (AtomicState s) r =>
(s -> s) -> Sem r ()
atomicModify' (IsLabel "projects" (ASetter s s a a)
ASetter s s a a
#projects ASetter s s a a -> a -> s -> s
forall a s t. Monoid a => ASetter s t a a -> a -> s -> t
<>~ [Item a
Project
project])

proAdd ::
  Members [Settings !! SettingError, Rpc !! RpcError, AtomicState Env, Reader PluginName, Log, Embed IO] r =>
  AddOptions ->
  Handler r ()
proAdd :: forall (r :: EffectRow).
Members
  '[Settings !! SettingError, Rpc !! RpcError, AtomicState Env,
    Reader PluginName, Log, Embed IO]
  r =>
AddOptions -> Handler r ()
proAdd (AddOptions ProjectName
name ProjectType
tpe Maybe Bool
activate) =
  forall (eff :: (* -> *) -> * -> *) e (r :: EffectRow) a.
(Reportable e, Members '[eff !! e, Stop Report] r) =>
Sem (eff : r) a -> Sem r a
resumeReport @Settings (Sem (Settings : Stop Report : r) () -> Sem (Stop Report : r) ())
-> Sem (Settings : Stop Report : r) () -> Sem (Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$ forall (eff :: (* -> *) -> * -> *) e (r :: EffectRow) a.
(Reportable e, Members '[eff !! e, Stop Report] r) =>
Sem (eff : r) a -> Sem r a
resumeReport @Rpc (Sem (Rpc : Settings : Stop Report : r) ()
 -> Sem (Settings : Stop Report : r) ())
-> Sem (Rpc : Settings : Stop Report : r) ()
-> Sem (Settings : Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$ Sem (Stop ResolveError : Rpc : Settings : Stop Report : r) ()
-> Sem (Rpc : Settings : Stop Report : r) ()
forall e (r :: EffectRow) a.
(Reportable e, Member (Stop Report) r) =>
Sem (Stop e : r) a -> Sem r a
mapReport do
    ProjectName
-> Maybe ProjectType
-> Bool
-> Sem (Stop ResolveError : Rpc : Settings : Stop Report : r) ()
forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
ProjectName -> Maybe ProjectType -> Bool -> Sem r ()
add ProjectName
name (ProjectType -> Maybe ProjectType
forall a. a -> Maybe a
Just ProjectType
tpe) (Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False Maybe Bool
activate)

addFromName ::
  Members [Settings, Rpc, AtomicState Env, Reader PluginName, Stop ResolveError, Log, Embed IO] r =>
  ProjectName ->
  Bool ->
  Sem r ()
addFromName :: forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
ProjectName -> Bool -> Sem r ()
addFromName ProjectName
name =
  ProjectName -> Maybe ProjectType -> Bool -> Sem r ()
forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
ProjectName -> Maybe ProjectType -> Bool -> Sem r ()
add ProjectName
name Maybe ProjectType
forall a. Maybe a
Nothing

proAddCmd ::
  Members [Settings !! SettingError, Rpc !! RpcError, AtomicState Env, Reader PluginName, Log, Embed IO] r =>
  Bang ->
  Text ->
  Handler r ()
proAddCmd :: forall (r :: EffectRow).
Members
  '[Settings !! SettingError, Rpc !! RpcError, AtomicState Env,
    Reader PluginName, Log, Embed IO]
  r =>
Bang -> Text -> Handler r ()
proAddCmd Bang
bang Text
spec =
  forall (eff :: (* -> *) -> * -> *) e (r :: EffectRow) a.
(Reportable e, Members '[eff !! e, Stop Report] r) =>
Sem (eff : r) a -> Sem r a
resumeReport @Settings (Sem (Settings : Stop Report : r) () -> Sem (Stop Report : r) ())
-> Sem (Settings : Stop Report : r) () -> Sem (Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$ forall (eff :: (* -> *) -> * -> *) e (r :: EffectRow) a.
(Reportable e, Members '[eff !! e, Stop Report] r) =>
Sem (eff : r) a -> Sem r a
resumeReport @Rpc (Sem (Rpc : Settings : Stop Report : r) ()
 -> Sem (Settings : Stop Report : r) ())
-> Sem (Rpc : Settings : Stop Report : r) ()
-> Sem (Settings : Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$ forall e (r :: EffectRow) a.
(Reportable e, Member (Stop Report) r) =>
Sem (Stop e : r) a -> Sem r a
mapReport @ResolveError (Sem (Stop ResolveError : Rpc : Settings : Stop Report : r) ()
 -> Sem (Rpc : Settings : Stop Report : r) ())
-> Sem (Stop ResolveError : Rpc : Settings : Stop Report : r) ()
-> Sem (Rpc : Settings : Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$ forall e (r :: EffectRow) a.
(Reportable e, Member (Stop Report) r) =>
Sem (Stop e : r) a -> Sem r a
mapReport @AddError do
    [Text]
-> Sem
     (Stop AddError
        : Stop ResolveError : Rpc : Settings : Stop Report : r)
     ()
process (Text -> Text -> [Text]
Text.splitOn Text
"/" Text
spec)
  where
    process :: [Text]
-> Sem
     (Stop AddError
        : Stop ResolveError : Rpc : Settings : Stop Report : r)
     ()
process [Item [Text]
tpe, Item [Text]
name] =
      ProjectName
-> Maybe ProjectType
-> Bool
-> Sem
     (Stop AddError
        : Stop ResolveError : Rpc : Settings : Stop Report : r)
     ()
forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
ProjectName -> Maybe ProjectType -> Bool -> Sem r ()
add (Text -> ProjectName
ProjectName Text
Item [Text]
name) (ProjectType -> Maybe ProjectType
forall a. a -> Maybe a
Just (Text -> ProjectType
ProjectType Text
Item [Text]
tpe)) Bool
activate
    process [Item [Text]
name] =
      ProjectName
-> Bool
-> Sem
     (Stop AddError
        : Stop ResolveError : Rpc : Settings : Stop Report : r)
     ()
forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
ProjectName -> Bool -> Sem r ()
addFromName (Text -> ProjectName
ProjectName Text
Item [Text]
name) (Bang
bang Bang -> Bang -> Bool
forall a. Eq a => a -> a -> Bool
== Bang
Bang)
    process [Text]
_ =
      AddError
-> Sem
     (Stop AddError
        : Stop ResolveError : Rpc : Settings : Stop Report : r)
     ()
forall e (r :: EffectRow) a. Member (Stop e) r => e -> Sem r a
stop (Text -> AddError
AddError.InvalidProjectSpec Text
spec)
    activate :: Bool
activate =
      Bang
bang Bang -> Bang -> Bool
forall a. Eq a => a -> a -> Bool
== Bang
Bang

availableProjectsInBase ::
  Members [Stop AddError, Embed IO] r =>
  Path Abs Dir ->
  Sem r [MenuItem AddItem]
availableProjectsInBase :: forall (r :: EffectRow).
Members '[Stop AddError, Embed IO] r =>
Path Abs Dir -> Sem r [MenuItem AddItem]
availableProjectsInBase Path Abs Dir
base =
  ([[Path Abs Dir]] -> [MenuItem AddItem])
-> Sem r [[Path Abs Dir]] -> Sem r [MenuItem AddItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Path Abs Dir -> MenuItem AddItem)
-> [Path Abs Dir] -> [MenuItem AddItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path Abs Dir -> MenuItem AddItem
cons ([Path Abs Dir] -> [MenuItem AddItem])
-> ([[Path Abs Dir]] -> [Path Abs Dir])
-> [[Path Abs Dir]]
-> [MenuItem AddItem]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Path Abs Dir]] -> [Path Abs Dir]
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join) (Sem r [[Path Abs Dir]] -> Sem r [MenuItem AddItem])
-> ([Path Abs Dir] -> Sem r [[Path Abs Dir]])
-> [Path Abs Dir]
-> Sem r [MenuItem AddItem]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Path Abs Dir -> Sem r [Path Abs Dir])
-> [Path Abs Dir] -> Sem r [[Path Abs Dir]]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Path Abs Dir -> Sem r [Path Abs Dir]
forall {r :: EffectRow} {b}.
(Member (Stop AddError) r, Member (Embed IO) r) =>
Path b Dir -> Sem r [Path Abs Dir]
list ([Path Abs Dir] -> Sem r [MenuItem AddItem])
-> Sem r [Path Abs Dir] -> Sem r [MenuItem AddItem]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Path Abs Dir -> Sem r [Path Abs Dir]
forall {r :: EffectRow} {b}.
(Member (Stop AddError) r, Member (Embed IO) r) =>
Path b Dir -> Sem r [Path Abs Dir]
list Path Abs Dir
base
  where
    list :: Path b Dir -> Sem r [Path Abs Dir]
list Path b Dir
d =
      (Text -> AddError)
-> Either Text [Path Abs Dir] -> Sem r [Path Abs Dir]
forall err' (r :: EffectRow) err a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith Text -> AddError
AddError.Directory (Either Text [Path Abs Dir] -> Sem r [Path Abs Dir])
-> Sem r (Either Text [Path Abs Dir]) -> Sem r [Path Abs Dir]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO [Path Abs Dir] -> Sem r (Either Text [Path Abs Dir])
forall (r :: EffectRow) a.
Member (Embed IO) r =>
IO a -> Sem r (Either Text a)
tryAny (([Path Abs Dir], [Path Abs File]) -> [Path Abs Dir]
forall a b. (a, b) -> a
fst (([Path Abs Dir], [Path Abs File]) -> [Path Abs Dir])
-> IO ([Path Abs Dir], [Path Abs File]) -> IO [Path Abs Dir]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Path b Dir -> IO ([Path Abs Dir], [Path Abs File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
listDir Path b Dir
d)
    cons :: Path Abs Dir -> MenuItem AddItem
cons Path Abs Dir
proj =
      AddItem -> Text -> Text -> MenuItem AddItem
forall a. a -> Text -> Text -> MenuItem a
MenuItem (Text -> Text -> AddItem
AddItem Text
tpe Text
name) Text
pt (Text -> (Path Rel Dir -> Text) -> Maybe (Path Rel Dir) -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
pt Path Rel Dir -> Text
forall b t. Path b t -> Text
dropSlash (Path Abs Dir -> Path Abs Dir -> Maybe (Path Rel Dir)
forall (m :: * -> *) b t.
MonadThrow m =>
Path b Dir -> Path b t -> m (Path Rel t)
stripProperPrefix Path Abs Dir
base Path Abs Dir
proj))
      where
        tpe :: Text
tpe =
          Path Rel Dir -> Text
forall b t. Path b t -> Text
dropSlash (Path Abs Dir -> Path Rel Dir
forall b. Path b Dir -> Path Rel Dir
dirname (Path Abs Dir -> Path Abs Dir
forall b t. Path b t -> Path b Dir
parent Path Abs Dir
proj))
        name :: Text
name =
          Path Rel Dir -> Text
forall b t. Path b t -> Text
dropSlash (Path Abs Dir -> Path Rel Dir
forall b. Path b Dir -> Path Rel Dir
dirname Path Abs Dir
proj)
        pt :: Text
pt =
          Path Abs Dir -> Text
forall b t. Path b t -> Text
pathText Path Abs Dir
proj

availableProjects ::
  Members [Stop AddError, Embed IO] r =>
  ProjectConfig ->
  Sem r [MenuItem AddItem]
availableProjects :: forall (r :: EffectRow).
Members '[Stop AddError, Embed IO] r =>
ProjectConfig -> Sem r [MenuItem AddItem]
availableProjects (ProjectConfig -> [Path Abs Dir]
ProjectConfig.baseDirs -> [Path Abs Dir]
dirs) =
  [[MenuItem AddItem]] -> [MenuItem AddItem]
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join ([[MenuItem AddItem]] -> [MenuItem AddItem])
-> Sem r [[MenuItem AddItem]] -> Sem r [MenuItem AddItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Path Abs Dir -> Sem r [MenuItem AddItem])
-> [Path Abs Dir] -> Sem r [[MenuItem AddItem]]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Path Abs Dir -> Sem r [MenuItem AddItem]
forall (r :: EffectRow).
Members '[Stop AddError, Embed IO] r =>
Path Abs Dir -> Sem r [MenuItem AddItem]
availableProjectsInBase [Path Abs Dir]
dirs

menuAdd ::
  Members [Settings, Rpc, AtomicState Env, Reader PluginName, Stop ResolveError, Log, Embed IO] r =>
  MenuWidget AddState r ()
menuAdd :: forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
MenuWidget AddState r ()
menuAdd =
  (Item AddState -> Sem (Menu AddState : Reader Prompt : r) ())
-> Sem (Menu AddState : Reader Prompt : r) (Maybe (MenuAction ()))
forall s (r :: EffectRow).
(MenuState s, Member (Menu s) r) =>
(Item s -> Sem r ()) -> Sem r (Maybe (MenuAction ()))
traverseSelection_ \ (AddItem Text
tpe Text
name) ->
    ProjectName
-> Maybe ProjectType
-> Bool
-> Sem (Menu AddState : Reader Prompt : r) ()
forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
ProjectName -> Maybe ProjectType -> Bool -> Sem r ()
add (Text -> ProjectName
ProjectName Text
name) (ProjectType -> Maybe ProjectType
forall a. a -> Maybe a
Just (Text -> ProjectType
ProjectType Text
tpe)) Bool
True

type AddStack =
  [
    ModalWindowMenus () AddItem !! RpcError,
    AtomicState Env,
    Reader PluginName,
    Settings !! SettingError,
    Rpc !! RpcError,
    Log,
    Embed IO
  ]

addMenu ::
  Members AddStack r =>
  Members [Rpc, Settings, Stop ResolveError, Stop AddError, Stop RpcError] r =>
  Sem r (MenuResult ())
addMenu :: forall (r :: EffectRow).
(Members AddStack r,
 Members
   '[Rpc, Settings, Stop ResolveError, Stop AddError, Stop RpcError]
   r) =>
Sem r (MenuResult ())
addMenu = do
  ProjectConfig
projectConfig <- Setting ProjectConfig -> Sem r ProjectConfig
forall a (r :: EffectRow).
(MsgpackDecode a, Member Settings r) =>
Setting a -> Sem r a
Settings.get Setting ProjectConfig
Settings.projectConfig
  [MenuItem AddItem]
projects <- [MenuItem AddItem] -> [MenuItem AddItem]
forall a. Ord a => [a] -> [a]
sort ([MenuItem AddItem] -> [MenuItem AddItem])
-> Sem r [MenuItem AddItem] -> Sem r [MenuItem AddItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ProjectConfig -> Sem r [MenuItem AddItem]
forall (r :: EffectRow).
Members '[Stop AddError, Embed IO] r =>
ProjectConfig -> Sem r [MenuItem AddItem]
availableProjects ProjectConfig
projectConfig
  [MenuItem (Item AddState)]
-> AddState
-> WindowOptions
-> Mappings AddState r ()
-> Sem r (MenuResult ())
forall mres result s (r :: EffectRow).
(MenuState s,
 Members
   '[UiMenus WindowConfig mres s !! RpcError, Log, Stop RpcError]
   r) =>
[MenuItem (Item s)]
-> s
-> WindowOptions
-> Mappings s r result
-> Sem r (MenuResult result)
staticWindowMenu [MenuItem (Item AddState)]
[MenuItem AddItem]
projects (Filter -> AddState
forall mode i. mode -> Modal mode i
modal Filter
Fuzzy) (WindowOptions
forall a. Default a => a
def WindowOptions -> (WindowOptions -> WindowOptions) -> WindowOptions
forall a b. a -> (a -> b) -> b
& IsLabel
  "items"
  (ASetter WindowOptions WindowOptions ScratchOptions ScratchOptions)
ASetter WindowOptions WindowOptions ScratchOptions ScratchOptions
#items ASetter WindowOptions WindowOptions ScratchOptions ScratchOptions
-> ScratchOptions -> WindowOptions -> WindowOptions
forall s t a b. ASetter s t a b -> b -> s -> t
.~ ScratchOptions
scratchOptions) [(MappingSpec
"<cr>", MenuWidget AddState r ()
forall (r :: EffectRow).
Members
  '[Settings, Rpc, AtomicState Env, Reader PluginName,
    Stop ResolveError, Log, Embed IO]
  r =>
MenuWidget AddState r ()
menuAdd)]
  where
    scratchOptions :: ScratchOptions
scratchOptions =
      (ScratchId -> ScratchOptions
scratch ScratchId
"proteome-add") { $sel:syntax:ScratchOptions :: [Syntax]
syntax = [Item [Syntax]
Syntax
addSyntax] }

proAddMenu ::
  Members AddStack r =>
  Handler r ()
proAddMenu :: forall (r :: EffectRow). Members AddStack r => Handler r ()
proAddMenu =
  forall (eff :: (* -> *) -> * -> *) e (r :: EffectRow) a.
(Reportable e, Members '[eff !! e, Stop Report] r) =>
Sem (eff : r) a -> Sem r a
resumeReport @Rpc (Sem (Rpc : Stop Report : r) () -> Sem (Stop Report : r) ())
-> Sem (Rpc : Stop Report : r) () -> Sem (Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$
  forall (eff :: (* -> *) -> * -> *) e (r :: EffectRow) a.
(Reportable e, Members '[eff !! e, Stop Report] r) =>
Sem (eff : r) a -> Sem r a
resumeReport @Settings (Sem (Settings : Rpc : Stop Report : r) ()
 -> Sem (Rpc : Stop Report : r) ())
-> Sem (Settings : Rpc : Stop Report : r) ()
-> Sem (Rpc : Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$
  forall e (r :: EffectRow) a.
(Reportable e, Member (Stop Report) r) =>
Sem (Stop e : r) a -> Sem r a
mapReport @AddError (Sem (Stop AddError : Settings : Rpc : Stop Report : r) ()
 -> Sem (Settings : Rpc : Stop Report : r) ())
-> Sem (Stop AddError : Settings : Rpc : Stop Report : r) ()
-> Sem (Settings : Rpc : Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$
  forall e (r :: EffectRow) a.
(Reportable e, Member (Stop Report) r) =>
Sem (Stop e : r) a -> Sem r a
mapReport @ResolveError (Sem
   (Stop ResolveError
      : Stop AddError : Settings : Rpc : Stop Report : r)
   ()
 -> Sem (Stop AddError : Settings : Rpc : Stop Report : r) ())
-> Sem
     (Stop ResolveError
        : Stop AddError : Settings : Rpc : Stop Report : r)
     ()
-> Sem (Stop AddError : Settings : Rpc : Stop Report : r) ()
forall a b. (a -> b) -> a -> b
$
  forall e (r :: EffectRow) a.
(Reportable e, Member (Stop Report) r) =>
Sem (Stop e : r) a -> Sem r a
mapReport @RpcError do
    Sem
  (Stop RpcError
     : Stop ResolveError : Stop AddError : Settings : Rpc : Stop Report
     : r)
  (MenuResult ())
-> Sem
     (Stop RpcError
        : Stop ResolveError : Stop AddError : Settings : Rpc : Stop Report
        : r)
     ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Sem
   (Stop RpcError
      : Stop ResolveError : Stop AddError : Settings : Rpc : Stop Report
      : r)
   (MenuResult ())
 -> Sem
      (Stop RpcError
         : Stop ResolveError : Stop AddError : Settings : Rpc : Stop Report
         : r)
      ())
-> Sem
     (Stop RpcError
        : Stop ResolveError : Stop AddError : Settings : Rpc : Stop Report
        : r)
     (MenuResult ())
-> Sem
     (Stop RpcError
        : Stop ResolveError : Stop AddError : Settings : Rpc : Stop Report
        : r)
     ()
forall a b. (a -> b) -> a -> b
$ Sem
  (Stop RpcError
     : Stop ResolveError : Stop AddError : Settings : Rpc : Stop Report
     : r)
  (MenuResult ())
forall (r :: EffectRow).
(Members AddStack r,
 Members
   '[Rpc, Settings, Stop ResolveError, Stop AddError, Stop RpcError]
   r) =>
Sem r (MenuResult ())
addMenu