Use EmbedIO instead of Embed IO

app/App.hs

@@ -45,7 +45,7 @@ makeLenses ''RunAppIOArgs
 
 runAppIO ::
   forall r a.
-  (Members '[Embed IO, TaggedLock] r) =>
+  (Members '[EmbedIO, TaggedLock] r) =>
   RunAppIOArgs ->
   Sem (App ': r) a ->
   Sem r a
@@ -55,7 +55,7 @@ runAppIO args = evalSingletonCache (readPackageRootIO root) . reAppIO args
 
 reAppIO ::
   forall r a.
-  (Members '[Embed IO, TaggedLock] r) =>
+  (Members '[EmbedIO, TaggedLock] r) =>
   RunAppIOArgs ->
   Sem (App ': r) a ->
   Sem (SCache Package ': r) a
@@ -92,10 +92,10 @@ reAppIO args@RunAppIOArgs {..} =
     getPkg :: (Members '[SCache Package] r') => Sem r' Package
     getPkg = cacheSingletonGet
 
-    exitMsg' :: (Members '[Embed IO] r') => IO x -> Text -> Sem r' x
+    exitMsg' :: (Members '[EmbedIO] r') => IO x -> Text -> Sem r' x
     exitMsg' onExit t = liftIO (putStrLn t >> hFlush stdout >> onExit)
 
-    getMainFile' :: (Members '[SCache Package, Embed IO] r') => Maybe (AppPath File) -> Sem r' (Path Abs File)
+    getMainFile' :: (Members '[SCache Package, EmbedIO] r') => Maybe (AppPath File) -> Sem r' (Path Abs File)
     getMainFile' = \case
       Just p -> embed (prepathToAbsFile invDir (p ^. pathPath))
       Nothing -> do
@@ -104,7 +104,7 @@ reAppIO args@RunAppIOArgs {..} =
           Just p -> embed (prepathToAbsFile invDir p)
           Nothing -> missingMainErr
 
-    missingMainErr :: (Members '[Embed IO] r') => Sem r' x
+    missingMainErr :: (Members '[EmbedIO] r') => Sem r' x
     missingMainErr =
       exitMsg'
         exitFailure
@@ -118,7 +118,7 @@ reAppIO args@RunAppIOArgs {..} =
     printErr e =
       embed $ hPutStrLn stderr $ run $ runReader (project' @GenericOptions g) $ Error.render (not (_runAppIOArgsGlobalOptions ^. globalNoColors)) (g ^. globalOnlyErrors) e
 
-getEntryPoint' :: (Members '[Embed IO, TaggedLock] r) => RunAppIOArgs -> AppPath File -> Sem r EntryPoint
+getEntryPoint' :: (Members '[EmbedIO, TaggedLock] r) => RunAppIOArgs -> AppPath File -> Sem r EntryPoint
 getEntryPoint' RunAppIOArgs {..} inputFile = do
   let opts = _runAppIOArgsGlobalOptions
       root = _runAppIOArgsRoot
@@ -128,19 +128,19 @@ getEntryPoint' RunAppIOArgs {..} inputFile = do
         | otherwise -> return Nothing
   set entryPointStdin estdin <$> entryPointFromGlobalOptionsPre root (inputFile ^. pathPath) opts
 
-runPipelineEither :: (Members '[Embed IO, TaggedLock, App] r) => AppPath File -> Sem (PipelineEff r) a -> Sem r (Either JuvixError (ResolverState, PipelineResult a))
+runPipelineEither :: (Members '[EmbedIO, TaggedLock, App] r) => AppPath File -> Sem (PipelineEff r) a -> Sem r (Either JuvixError (ResolverState, PipelineResult a))
 runPipelineEither input_ p = do
   args <- askArgs
   entry <- getEntryPoint' args input_
   runIOEither entry p
 
-runPipelineSetupEither :: (Members '[Embed IO, TaggedLock, App] r) => Sem (PipelineEff' r) a -> Sem r (Either JuvixError (ResolverState, a))
+runPipelineSetupEither :: (Members '[EmbedIO, TaggedLock, App] r) => Sem (PipelineEff' r) a -> Sem r (Either JuvixError (ResolverState, a))
 runPipelineSetupEither p = do
   args <- askArgs
   entry <- getEntryPointStdin' args
   runIOEitherPipeline entry p
 
-getEntryPointStdin' :: (Members '[Embed IO, TaggedLock] r) => RunAppIOArgs -> Sem r EntryPoint
+getEntryPointStdin' :: (Members '[EmbedIO, TaggedLock] r) => RunAppIOArgs -> Sem r EntryPoint
 getEntryPointStdin' RunAppIOArgs {..} = do
   let opts = _runAppIOArgsGlobalOptions
       root = _runAppIOArgsRoot
@@ -155,41 +155,41 @@ someBaseToAbs' f = do
   r <- askInvokeDir
   return (someBaseToAbs r f)
 
-filePathToAbs :: (Members '[Embed IO, App] r) => Prepath FileOrDir -> Sem r (Either (Path Abs File) (Path Abs Dir))
+filePathToAbs :: (Members '[EmbedIO, App] r) => Prepath FileOrDir -> Sem r (Either (Path Abs File) (Path Abs Dir))
 filePathToAbs fp = do
   invokeDir <- askInvokeDir
   embed (fromPreFileOrDir invokeDir fp)
 
 askGenericOptions :: (Members '[App] r) => Sem r GenericOptions
 askGenericOptions = project <$> askGlobalOptions
 
-getEntryPoint :: (Members '[Embed IO, App, TaggedLock] r) => AppPath File -> Sem r EntryPoint
+getEntryPoint :: (Members '[EmbedIO, App, TaggedLock] r) => AppPath File -> Sem r EntryPoint
 getEntryPoint inputFile = do
   _runAppIOArgsGlobalOptions <- askGlobalOptions
   _runAppIOArgsRoot <- askRoot
   getEntryPoint' (RunAppIOArgs {..}) inputFile
 
-getEntryPointStdin :: (Members '[Embed IO, App, TaggedLock] r) => Sem r EntryPoint
+getEntryPointStdin :: (Members '[EmbedIO, App, TaggedLock] r) => Sem r EntryPoint
 getEntryPointStdin = do
   _runAppIOArgsGlobalOptions <- askGlobalOptions
   _runAppIOArgsRoot <- askRoot
   getEntryPointStdin' (RunAppIOArgs {..})
 
-runPipelineTermination :: (Members '[Embed IO, App, TaggedLock] r) => AppPath File -> Sem (Termination ': PipelineEff r) a -> Sem r (PipelineResult a)
+runPipelineTermination :: (Members '[EmbedIO, App, TaggedLock] r) => AppPath File -> Sem (Termination ': PipelineEff r) a -> Sem r (PipelineResult a)
 runPipelineTermination input_ p = do
   r <- runPipelineEither input_ (evalTermination iniTerminationState p)
   case r of
     Left err -> exitJuvixError err
     Right res -> return (snd res)
 
-runPipeline :: (Members '[App, Embed IO, TaggedLock] r) => AppPath File -> Sem (PipelineEff r) a -> Sem r a
+runPipeline :: (Members '[App, EmbedIO, TaggedLock] r) => AppPath File -> Sem (PipelineEff r) a -> Sem r a
 runPipeline input_ p = do
   r <- runPipelineEither input_ p
   case r of
     Left err -> exitJuvixError err
     Right res -> return (snd res ^. pipelineResult)
 
-runPipelineHtml :: (Members '[App, Embed IO, TaggedLock] r) => Bool -> AppPath File -> Sem r (InternalTypedResult, [InternalTypedResult])
+runPipelineHtml :: (Members '[App, EmbedIO, TaggedLock] r) => Bool -> AppPath File -> Sem r (InternalTypedResult, [InternalTypedResult])
 runPipelineHtml bNonRecursive input_
   | bNonRecursive = do
       r <- runPipeline input_ upToInternalTyped
@@ -202,14 +202,14 @@ runPipelineHtml bNonRecursive input_
         Left err -> exitJuvixError err
         Right res -> return res
 
-runPipelineEntry :: (Members '[App, Embed IO, TaggedLock] r) => EntryPoint -> Sem (PipelineEff r) a -> Sem r a
+runPipelineEntry :: (Members '[App, EmbedIO, TaggedLock] r) => EntryPoint -> Sem (PipelineEff r) a -> Sem r a
 runPipelineEntry entry p = do
   r <- runIOEither entry p
   case r of
     Left err -> exitJuvixError err
     Right res -> return (snd res ^. pipelineResult)
 
-runPipelineSetup :: (Members '[App, Embed IO, TaggedLock] r) => Sem (PipelineEff' r) a -> Sem r a
+runPipelineSetup :: (Members '[App, EmbedIO, TaggedLock] r) => Sem (PipelineEff' r) a -> Sem r a
 runPipelineSetup p = do
   r <- runPipelineSetupEither p
   case r of

app/AsmInterpreter.hs

@@ -8,7 +8,7 @@ import Juvix.Compiler.Asm.Interpreter qualified as Asm
 import Juvix.Compiler.Asm.Pretty qualified as Asm
 import Juvix.Compiler.Asm.Transformation.Validate qualified as Asm
 
-runAsm :: forall r. (Members '[Embed IO, App] r) => Bool -> Asm.InfoTable -> Sem r ()
+runAsm :: forall r. (Members '[EmbedIO, App] r) => Bool -> Asm.InfoTable -> Sem r ()
 runAsm bValidate tab =
   let v = if bValidate then Asm.validate' tab else Nothing
    in case v of

app/Commands/Compile.hs

@@ -8,7 +8,7 @@ import Juvix.Compiler.Core qualified as Core
 import Juvix.Compiler.Core.Pretty qualified as Core
 import Juvix.Compiler.Core.Transformation.DisambiguateNames qualified as Core
 
-runCommand :: (Members '[Embed IO, App, TaggedLock] r) => CompileOptions -> Sem r ()
+runCommand :: (Members '[EmbedIO, App, TaggedLock] r) => CompileOptions -> Sem r ()
 runCommand opts@CompileOptions {..} = do
   inputFile <- getMainFile _compileInputFile
   Core.CoreResult {..} <- runPipeline (AppPath (preFileFromAbs inputFile) True) upToCore
@@ -29,7 +29,7 @@ runCommand opts@CompileOptions {..} = do
     TargetReg -> Compile.runRegPipeline arg
     TargetNockma -> Compile.runNockmaPipeline arg
 
-writeCoreFile :: (Members '[Embed IO, App, TaggedLock] r) => Compile.PipelineArg -> Sem r ()
+writeCoreFile :: (Members '[EmbedIO, App, TaggedLock] r) => Compile.PipelineArg -> Sem r ()
 writeCoreFile [email protected] {..} = do
   entryPoint <- Compile.getEntry pa
   coreFile <- Compile.outputFile _pipelineArgOptions _pipelineArgFile

app/Commands/Dependencies.hs

@@ -8,6 +8,6 @@ import Commands.Base
 import Commands.Dependencies.Options
 import Commands.Dependencies.Update qualified as Update
 
-runCommand :: (Members '[Embed IO, TaggedLock, App] r) => DependenciesCommand -> Sem r ()
+runCommand :: (Members '[EmbedIO, TaggedLock, App] r) => DependenciesCommand -> Sem r ()
 runCommand = \case
   Update -> Update.runCommand

app/Commands/Dependencies/Update.hs

@@ -4,5 +4,5 @@ import Commands.Base
 import Juvix.Compiler.Pipeline.Loader.PathResolver
 import Juvix.Compiler.Pipeline.Setup
 
-runCommand :: (Members '[Embed IO, TaggedLock, App] r) => Sem r ()
+runCommand :: (Members '[EmbedIO, TaggedLock, App] r) => Sem r ()
 runCommand = runPipelineSetup (entrySetup (set dependenciesConfigForceUpdateLockfile True defaultDependenciesConfig))

app/Commands/Dev.hs

@@ -23,7 +23,7 @@ import Commands.Dev.Termination qualified as Termination
 import Commands.Dev.Tree qualified as Tree
 import Commands.Repl qualified as Repl
 
-runCommand :: (Members '[Embed IO, App, TaggedLock] r) => DevCommand -> Sem r ()
+runCommand :: (Members '[EmbedIO, App, TaggedLock] r) => DevCommand -> Sem r ()
 runCommand = \case
   Highlight opts -> Highlight.runCommand opts
   Parse opts -> Parse.runCommand opts

app/Commands/Dev/Asm.hs

@@ -6,7 +6,7 @@ import Commands.Dev.Asm.Options
 import Commands.Dev.Asm.Run as Run
 import Commands.Dev.Asm.Validate as Validate
 
-runCommand :: forall r. (Members '[Embed IO, App, TaggedLock] r) => AsmCommand -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App, TaggedLock] r) => AsmCommand -> Sem r ()
 runCommand = \case
   Run opts -> Run.runCommand opts
   Validate opts -> Validate.runCommand opts

app/Commands/Dev/Asm/Compile.hs

@@ -8,7 +8,7 @@ import Juvix.Compiler.Backend qualified as Backend
 import Juvix.Compiler.Backend.C qualified as C
 import Juvix.Compiler.Reg.Pretty qualified as Reg
 
-runCommand :: forall r. (Members '[Embed IO, App, TaggedLock] r) => AsmCompileOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App, TaggedLock] r) => AsmCompileOptions -> Sem r ()
 runCommand opts = do
   file <- getFile
   s <- readFile (toFilePath file)

app/Commands/Dev/Asm/Run.hs

@@ -5,7 +5,7 @@ import Commands.Base
 import Commands.Dev.Asm.Run.Options
 import Juvix.Compiler.Asm.Translation.FromSource qualified as Asm
 
-runCommand :: forall r. (Members '[Embed IO, App] r) => AsmRunOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App] r) => AsmRunOptions -> Sem r ()
 runCommand opts = do
   afile :: Path Abs File <- fromAppPathFile file
   s <- readFile (toFilePath afile)

app/Commands/Dev/Asm/Validate.hs

@@ -6,7 +6,7 @@ import Juvix.Compiler.Asm.Pretty qualified as Asm
 import Juvix.Compiler.Asm.Transformation.Validate qualified as Asm
 import Juvix.Compiler.Asm.Translation.FromSource qualified as Asm
 
-runCommand :: forall r. (Members '[Embed IO, App] r) => AsmValidateOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App] r) => AsmValidateOptions -> Sem r ()
 runCommand opts = do
   afile :: Path Abs File <- fromAppPathFile file
   s <- readFile (toFilePath afile)

app/Commands/Dev/Casm.hs

@@ -5,7 +5,7 @@ import Commands.Dev.Casm.Options
 import Commands.Dev.Casm.Read as Read
 import Commands.Dev.Casm.Run as Run
 
-runCommand :: forall r. (Members '[Embed IO, App, TaggedLock] r) => CasmCommand -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App, TaggedLock] r) => CasmCommand -> Sem r ()
 runCommand = \case
   Run opts -> Run.runCommand opts
   Read opts -> Read.runCommand opts

app/Commands/Dev/Casm/Read.hs

@@ -6,7 +6,7 @@ import Juvix.Compiler.Casm.Pretty qualified as Casm
 import Juvix.Compiler.Casm.Translation.FromSource qualified as Casm
 import Juvix.Compiler.Casm.Validate qualified as Casm
 
-runCommand :: forall r. (Members '[Embed IO, App] r) => CasmReadOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App] r) => CasmReadOptions -> Sem r ()
 runCommand opts = do
   afile :: Path Abs File <- fromAppPathFile file
   s <- readFile (toFilePath afile)

app/Commands/Dev/Casm/Run.hs

@@ -6,7 +6,7 @@ import Juvix.Compiler.Casm.Interpreter qualified as Casm
 import Juvix.Compiler.Casm.Translation.FromSource qualified as Casm
 import Juvix.Compiler.Casm.Validate qualified as Casm
 
-runCommand :: forall r. (Members '[Embed IO, App] r) => CasmRunOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App] r) => CasmRunOptions -> Sem r ()
 runCommand opts = do
   afile :: Path Abs File <- fromAppPathFile file
   s <- readFile (toFilePath afile)

app/Commands/Dev/Core.hs

@@ -11,7 +11,7 @@ import Commands.Dev.Core.Read as Read
 import Commands.Dev.Core.Repl as Repl
 import Commands.Dev.Core.Strip as Strip
 
-runCommand :: forall r. (Members '[Embed IO, App, TaggedLock] r) => CoreCommand -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App, TaggedLock] r) => CoreCommand -> Sem r ()
 runCommand = \case
   Repl opts -> Repl.runCommand opts
   Eval opts -> Eval.runCommand opts

app/Commands/Dev/Core/Asm.hs

@@ -6,7 +6,7 @@ import Commands.Dev.Core.Asm.Options
 import Juvix.Compiler.Asm qualified as Asm
 import Juvix.Compiler.Core qualified as Core
 
-runCommand :: forall r a. (Members '[Embed IO, App, TaggedLock] r, CanonicalProjection a CoreAsmOptions) => a -> Sem r ()
+runCommand :: forall r a. (Members '[EmbedIO, App, TaggedLock] r, CanonicalProjection a CoreAsmOptions) => a -> Sem r ()
 runCommand opts = do
   inputFile :: Path Abs File <- fromAppPathFile sinputFile
   ep <- getEntryPoint sinputFile

app/Commands/Dev/Core/Compile.hs

@@ -6,7 +6,7 @@ import Commands.Dev.Core.Compile.Options
 import Juvix.Compiler.Core.Data.Module qualified as Core
 import Juvix.Compiler.Core.Translation.FromSource qualified as Core
 
-runCommand :: forall r. (Members '[Embed IO, App, TaggedLock] r) => CompileOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App, TaggedLock] r) => CompileOptions -> Sem r ()
 runCommand opts = do
   file <- getFile
   s <- readFile (toFilePath file)

app/Commands/Dev/Core/Compile/Base.hs

@@ -20,7 +20,7 @@ data PipelineArg = PipelineArg
     _pipelineArgModule :: Core.Module
   }
 
-getEntry :: (Members '[Embed IO, App, TaggedLock] r) => PipelineArg -> Sem r EntryPoint
+getEntry :: (Members '[EmbedIO, App, TaggedLock] r) => PipelineArg -> Sem r EntryPoint
 getEntry PipelineArg {..} = do
   ep <- getEntryPoint (AppPath (preFileFromAbs _pipelineArgFile) True)
   return $
@@ -51,7 +51,7 @@ getEntry PipelineArg {..} = do
 
 runCPipeline ::
   forall r.
-  (Members '[Embed IO, App, TaggedLock] r) =>
+  (Members '[EmbedIO, App, TaggedLock] r) =>
   PipelineArg ->
   Sem r ()
 runCPipeline pa@PipelineArg {..} = do
@@ -74,7 +74,7 @@ runCPipeline pa@PipelineArg {..} = do
 
 runGebPipeline ::
   forall r.
-  (Members '[Embed IO, App, TaggedLock] r) =>
+  (Members '[EmbedIO, App, TaggedLock] r) =>
   PipelineArg ->
   Sem r ()
 runGebPipeline pa@PipelineArg {..} = do
@@ -93,7 +93,7 @@ runGebPipeline pa@PipelineArg {..} = do
 
 runVampIRPipeline ::
   forall r.
-  (Members '[Embed IO, App, TaggedLock] r) =>
+  (Members '[EmbedIO, App, TaggedLock] r) =>
   PipelineArg ->
   Sem r ()
 runVampIRPipeline pa@PipelineArg {..} = do
@@ -102,7 +102,7 @@ runVampIRPipeline pa@PipelineArg {..} = do
   VampIR.Result {..} <- getRight (run (runReader entryPoint (runError (coreToVampIR _pipelineArgModule :: Sem '[Error JuvixError, Reader EntryPoint] VampIR.Result))))
   writeFileEnsureLn vampirFile _resultCode
 
-runAsmPipeline :: (Members '[Embed IO, App, TaggedLock] r) => PipelineArg -> Sem r ()
+runAsmPipeline :: (Members '[EmbedIO, App, TaggedLock] r) => PipelineArg -> Sem r ()
 runAsmPipeline pa@PipelineArg {..} = do
   entryPoint <- getEntry pa
   asmFile <- Compile.outputFile _pipelineArgOptions _pipelineArgFile
@@ -115,7 +115,7 @@ runAsmPipeline pa@PipelineArg {..} = do
   let code = Asm.ppPrint tab' tab'
   writeFileEnsureLn asmFile code
 
-runRegPipeline :: (Members '[Embed IO, App, TaggedLock] r) => PipelineArg -> Sem r ()
+runRegPipeline :: (Members '[EmbedIO, App, TaggedLock] r) => PipelineArg -> Sem r ()
 runRegPipeline pa@PipelineArg {..} = do
   entryPoint <- getEntry pa
   regFile <- Compile.outputFile _pipelineArgOptions _pipelineArgFile
@@ -128,7 +128,7 @@ runRegPipeline pa@PipelineArg {..} = do
   let code = Reg.ppPrint tab' tab'
   writeFileEnsureLn regFile code
 
-runTreePipeline :: (Members '[Embed IO, App, TaggedLock] r) => PipelineArg -> Sem r ()
+runTreePipeline :: (Members '[EmbedIO, App, TaggedLock] r) => PipelineArg -> Sem r ()
 runTreePipeline pa@PipelineArg {..} = do
   entryPoint <- getEntry pa
   treeFile <- Compile.outputFile _pipelineArgOptions _pipelineArgFile
@@ -141,7 +141,7 @@ runTreePipeline pa@PipelineArg {..} = do
   let code = Tree.ppPrint tab' tab'
   writeFileEnsureLn treeFile code
 
-runNockmaPipeline :: (Members '[Embed IO, App, TaggedLock] r) => PipelineArg -> Sem r ()
+runNockmaPipeline :: (Members '[EmbedIO, App, TaggedLock] r) => PipelineArg -> Sem r ()
 runNockmaPipeline pa@PipelineArg {..} = do
   entryPoint <- getEntry pa
   nockmaFile <- Compile.outputFile _pipelineArgOptions _pipelineArgFile

app/Commands/Dev/Core/Eval.hs

@@ -5,7 +5,7 @@ import Commands.Dev.Core.Eval.Options
 import Evaluator
 import Juvix.Compiler.Core.Translation.FromSource qualified as Core
 
-runCommand :: forall r. (Members '[Embed IO, App] r) => CoreEvalOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App] r) => CoreEvalOptions -> Sem r ()
 runCommand opts = do
   f :: Path Abs File <- fromAppPathFile b
   s <- readFile (toFilePath f)

app/Commands/Dev/Core/FromConcrete.hs

@@ -11,7 +11,7 @@ import Juvix.Compiler.Core.Transformation qualified as Core
 import Juvix.Compiler.Core.Transformation.DisambiguateNames (disambiguateNames')
 import Juvix.Compiler.Core.Translation
 
-runCommand :: forall r. (Members '[Embed IO, TaggedLock, App] r) => CoreFromConcreteOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, TaggedLock, App] r) => CoreFromConcreteOptions -> Sem r ()
 runCommand localOpts = do
   gopts <- askGlobalOptions
   md <- (^. coreResultModule) <$> runPipeline (localOpts ^. coreFromConcreteInputFile) upToCore

app/Commands/Dev/Core/Normalize.hs

@@ -5,7 +5,7 @@ import Commands.Dev.Core.Normalize.Options
 import Evaluator
 import Juvix.Compiler.Core.Translation.FromSource qualified as Core
 
-runCommand :: forall r. (Members '[Embed IO, App] r) => CoreNormalizeOptions -> Sem r ()
+runCommand :: forall r. (Members '[EmbedIO, App] r) => CoreNormalizeOptions -> Sem r ()
 runCommand opts = do
   f :: Path Abs File <- fromAppPathFile b
   s <- readFile (toFilePath f)

app/Commands/Dev/Core/Read.hs

@@ -12,7 +12,7 @@ import Juvix.Compiler.Core.Translation.FromSource qualified as Core
 
 runCommand ::
   forall r a.
-  ( Members '[Embed IO, App] r,
+  ( Members '[EmbedIO, App] r,
     CanonicalProjection a Eval.EvalOptions,
     CanonicalProjection a Pretty.Options,
     CanonicalProjection a CoreReadOptions