eo-phi-normalizer 1.0.0 → 1.1.0
raw patch · 19 files changed
+7648/−252 lines, 19 files
Files
- CHANGELOG.md +27/−0
- app/Main.hs +113/−57
- data/0.36.0/dependencies.md +1994/−0
- data/0.37.0/dependencies.md +1714/−0
- data/0.38.0/dependencies.md +1704/−0
- data/0.38.4/dependencies.md +1755/−0
- eo-phi-normalizer.cabal +10/−2
- src/Language/EO/Phi/Dataize.hs +35/−154
- src/Language/EO/Phi/Dataize/Atoms.hs +94/−0
- src/Language/EO/Phi/Dataize/Context.hs +39/−0
- src/Language/EO/Phi/Report/Html.hs +51/−20
- src/Language/EO/Phi/Rules/Common.hs +7/−5
- src/Language/EO/Phi/Rules/RunYegor.hs +1/−1
- src/Language/EO/Phi/Rules/Yaml.hs +7/−0
- src/Language/EO/Phi/ToLaTeX.hs +89/−7
- test/Language/EO/Phi/DataizeSpec.hs +2/−1
- test/Language/EO/PhiSpec.hs +1/−1
- test/Language/EO/Rules/PhiPaperSpec.hs +1/−1
- test/Language/EO/YamlSpec.hs +4/−3
CHANGELOG.md view
@@ -6,6 +6,33 @@ and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/). +## v1.1.0 - 2024-10-03++### New++- Add unit tests [#461](https://github.com/objectionary/normalizer/pull/461)+- Add `R_DOT_ρ` [#468](https://github.com/objectionary/normalizer/pull/468)+- Support printing rules in LaTeX [#474](https://github.com/objectionary/normalizer/pull/474)+- Automatically create an output directory [#499](https://github.com/objectionary/normalizer/pull/499)++### Changes and fixes++- Update the `COPY` rule as in phi-paper [#445](https://github.com/objectionary/normalizer/pull/445)+- Remove special case for delta binding since VTX is removed [#356](https://github.com/objectionary/normalizer/pull/356)+- Replace `normalizer report` command with the `normalizer pipeline report` command [#456](https://github.com/objectionary/normalizer/pull/456)+- Fix sorting in numeric columns [#460](https://github.com/objectionary/normalizer/pull/460)+- Run mdbook in the pipeline job [#463](https://github.com/objectionary/normalizer/pull/463)++### Documentation and maintenance++- Document all dependencies in a single doc in `eo/phi/normalizer/data` for each eo version [#446](https://github.com/objectionary/normalizer/pull/446).+- Create a metrics page on the site [#453](https://github.com/objectionary/normalizer/pull/453)+- Chore(deps): update dependency pre-commit to v3.8.0 [#455](https://github.com/objectionary/normalizer/pull/455)+- Provide instructions for the customer to check that we've completed the contract requirements [#458](https://github.com/objectionary/normalizer/pull/458)+- Bump stack action version [#459](https://github.com/objectionary/normalizer/pull/459)+- Update proposal process [#464](https://github.com/objectionary/normalizer/pull/464)+- Document creating custom atoms on the site [#467](https://github.com/objectionary/normalizer/pull/467)+ ## v1.0.0 - 2024-07-19 ### New
app/Main.hs view
@@ -42,16 +42,18 @@ import GHC.Generics (Generic) import Language.EO.Phi (Binding (..), Bytes (Bytes), Object (..), Program (Program), parseProgram, printTree) import Language.EO.Phi.Dataize+import Language.EO.Phi.Dataize.Context import Language.EO.Phi.Dependencies import Language.EO.Phi.Metrics.Collect as Metrics (getProgramMetrics) import Language.EO.Phi.Metrics.Data as Metrics (ProgramMetrics (..), splitPath) import Language.EO.Phi.Pipeline.Config-import Language.EO.Phi.Pipeline.Dataize.PrintConfigs-import Language.EO.Phi.Pipeline.EOTests.PrepareTests (prepareTests)+import Language.EO.Phi.Pipeline.Dataize.PrintConfigs as PrintConfigs+import Language.EO.Phi.Pipeline.EOTests.PrepareTests as PrepareTests import Language.EO.Phi.Report.Data (makeProgramReport, makeReport) import Language.EO.Phi.Report.Html (reportCSS, reportJS, toStringReport) import Language.EO.Phi.Rules.Common import Language.EO.Phi.Rules.Fast (fastYegorInsideOut, fastYegorInsideOutAsRule)+import Language.EO.Phi.Rules.RunYegor (yegorRuleSet) import Language.EO.Phi.Rules.Yaml (RuleSet (rules, title), convertRuleNamed, parseRuleSetFromFile) import Language.EO.Phi.ToLaTeX import Main.Utf8@@ -74,7 +76,7 @@ , maxDepth :: Int , maxGrowthFactor :: Int }- deriving (Show)+ deriving stock (Show) data CLI'DataizePhi = CLI'DataizePhi { rulesPath :: Maybe String@@ -90,38 +92,52 @@ , disabledAtomNames :: [String] , enabledAtomNames :: [String] }- deriving (Show)+ deriving stock (Show) data CLI'MetricsPhi = CLI'MetricsPhi { inputFile :: Maybe FilePath , outputFile :: Maybe FilePath , bindingsPath :: Maybe String }- deriving (Show)+ deriving stock (Show) -newtype CLI'ReportPhi = CLI'ReportPhi+data CLI'PrintRules = CLI'PrintRules+ { rulesPath :: Maybe String+ , latex :: Bool+ , compact :: Bool+ }+ deriving stock (Show)++newtype CLI'Pipeline'Report = CLI'Pipeline'Report { configFile :: FilePath }- deriving (Show)+ deriving stock (Show) +newtype CLI'Pipeline'PrepareTests = CLI'Pipeline'PrepareTests+ { configFile :: FilePath+ }+ deriving stock (Show)++data CLI'Pipeline'PrintDataizeConfigs = CLI'Pipeline'PrintDataizeConfigs+ { configFile :: FilePath+ , phiPrefixesToStrip :: [FilePath]+ , singleLine :: Bool+ }+ deriving stock (Show)+ data CLI'Pipeline- = CLI'Pipeline'PrepareTests- { configFile :: FilePath- }- | CLI'Pipeline'PrintDataizeConfigs- { configFile :: FilePath- , phiPrefixesToStrip :: [FilePath]- , singleLine :: Bool- }- deriving (Show)+ = CLI'Pipeline'Report' CLI'Pipeline'Report+ | CLI'Pipeline'PrepareTests' CLI'Pipeline'PrepareTests+ | CLI'Pipeline'PrintDataizeConfigs' CLI'Pipeline'PrintDataizeConfigs+ deriving stock (Show) data CLI = CLI'TransformPhi' CLI'TransformPhi | CLI'DataizePhi' CLI'DataizePhi | CLI'MetricsPhi' CLI'MetricsPhi- | CLI'ReportPhi' CLI'ReportPhi+ | CLI'PrintRules' CLI'PrintRules | CLI'Pipeline' CLI'Pipeline- deriving (Show)+ deriving stock (Show) data MetavarName = MetavarName { file :: String@@ -182,6 +198,9 @@ latexSwitch :: Parser Bool latexSwitch = switch (long "tex" <> help "Output LaTeX.") +compactSwitch :: Parser Bool+compactSwitch = switch (long "compact" <> short 'c' <> help "Print rules, each on a single line.")+ asPackageSwitch :: Parser Bool asPackageSwitch = switch (long "as-package" <> help "Automatically inject (λ → Package) in the program if necessary, to dataize all fields.") @@ -204,14 +223,19 @@ |] ) +data CommandParser'Pipeline = CommandParser'Pipeline+ { report :: Parser CLI'Pipeline'Report+ , prepareTests :: Parser CLI'Pipeline'PrepareTests+ , printDataizeConfigs :: Parser CLI'Pipeline'PrintDataizeConfigs+ }+ data CommandParser = CommandParser { metrics :: Parser CLI'MetricsPhi , transform :: Parser CLI'TransformPhi , dataize :: Parser CLI'DataizePhi- , report :: Parser CLI'ReportPhi , pipeline :: Parser CLI'Pipeline- , pipelinePrepareTests :: Parser CLI'Pipeline- , pipelinePrintDataizeConfigs :: Parser CLI'Pipeline+ , pipeline' :: CommandParser'Pipeline+ , printRules :: Parser CLI'PrintRules } commandParser :: CommandParser@@ -223,7 +247,11 @@ outputFile <- outputFileOption bindingsPath <- bindingsPathOption pure CLI'MetricsPhi{..}-+ printRules = do+ rulesPath <- optional $ strOption (long "rules" <> short 'r' <> metavar.file <> help [fmt|{metavarName.file} with user-defined rules. If unspecified, yegor.yaml is rendered.|])+ latex <- latexSwitch+ compact <- compactSwitch+ pure CLI'PrintRules{..} transform = do rulesPath <- optional $ strOption (long "rules" <> short 'r' <> metavar.file <> help [fmt|{metavarName.file} with user-defined rules. If unspecified, builtin set of rules is used.|]) chain <- switch (long "chain" <> short 'c' <> help "Output transformation steps.")@@ -251,34 +279,43 @@ latex <- latexSwitch asPackage <- asPackageSwitch minimizeStuckTerms <- minimizeStuckTermsSwitch- disabledAtomNames <- many $ strOption (long "disable-atom" <> metavar.atomName <> help "Disable a particular atom by its name.")- enabledAtomNames <- many $ strOption (long "enable-atom" <> metavar.atomName <> help "Enable a particular atom by its name.")+ disabledAtomNames <- many $ strOption (long "disable-atom" <> metavar.atomName <> help "Name of an atom to disable.")+ enabledAtomNames <- many $ strOption (long "enable-atom" <> metavar.atomName <> help "Name of an atom to enable.") pure CLI'DataizePhi{..}- report = do- configFile <- strOption (long "config" <> short 'c' <> metavar.file <> help [fmt|A report configuration {metavarName.file}.|])- pure CLI'ReportPhi{..}- pipelinePrepareTests = do- configFile <- strOption (long "config" <> short 'c' <> metavar.file <> help [fmt|A pipeline tests configuration {metavarName.file}.|])- pure CLI'Pipeline'PrepareTests{..}- pipelinePrintDataizeConfigs = do- configFile <- strOption (long "config" <> short 'c' <> metavar.file <> help [fmt|A pipeline tests configuration {metavarName.file}.|])- phiPrefixesToStrip <- many $ strOption (long "strip-phi-prefix" <> short 'p' <> metavar.atomName <> help "Remove prefixes in PHI file paths.")- singleLine <- switch (long "single-line" <> short 'l' <> help [fmt|Output configs on an single line.|])- pure CLI'Pipeline'PrintDataizeConfigs{..}+ pipeline' =+ CommandParser'Pipeline+ { report = do+ configFile <- strOption (long "config" <> short 'c' <> metavar.file <> help [fmt|A report configuration {metavarName.file}.|])+ pure CLI'Pipeline'Report{..}+ , prepareTests = do+ configFile <- strOption (long "config" <> short 'c' <> metavar.file <> help [fmt|A pipeline tests configuration {metavarName.file}.|])+ pure CLI'Pipeline'PrepareTests{..}+ , printDataizeConfigs = do+ configFile <- strOption (long "config" <> short 'c' <> metavar.file <> help [fmt|A pipeline tests configuration {metavarName.file}.|])+ phiPrefixesToStrip <- many $ strOption (long "strip-phi-prefix" <> short 'p' <> metavar.path <> help [fmt|{metavarName.path} prefix to remove in PHI file paths.|])+ singleLine <- switch (long "single-line" <> short 'l' <> help [fmt|Output configs on an single line.|])+ pure CLI'Pipeline'PrintDataizeConfigs{..}+ } pipeline = hsubparser- ( command commandNames.pipelinePrepareTests commandParserInfo.pipelinePrepareTests- <> command commandNames.pipelinePrintDataizeConfigs commandParserInfo.pipelinePrintDataizeConfigs+ ( command commandNames.pipeline'.report commandParserInfo.pipeline'.report+ <> command commandNames.pipeline'.prepareTests commandParserInfo.pipeline'.prepareTests+ <> command commandNames.pipeline'.printDataizeConfigs commandParserInfo.pipeline'.printDataizeConfigs ) +data CommandParserInfo'Pipeline = CommandParserInfo'Pipeline+ { report :: ParserInfo CLI'Pipeline+ , prepareTests :: ParserInfo CLI'Pipeline+ , printDataizeConfigs :: ParserInfo CLI'Pipeline+ }+ data CommandParserInfo = CommandParserInfo { metrics :: ParserInfo CLI , transform :: ParserInfo CLI , dataize :: ParserInfo CLI- , report :: ParserInfo CLI+ , printRules :: ParserInfo CLI , pipeline :: ParserInfo CLI- , pipelinePrepareTests :: ParserInfo CLI'Pipeline- , pipelinePrintDataizeConfigs :: ParserInfo CLI'Pipeline+ , pipeline' :: CommandParserInfo'Pipeline } commandParserInfo :: CommandParserInfo@@ -287,20 +324,29 @@ { metrics = info (CLI'MetricsPhi' <$> commandParser.metrics) (progDesc "Collect metrics for a PHI program.") , transform = info (CLI'TransformPhi' <$> commandParser.transform) (progDesc "Transform a PHI program.") , dataize = info (CLI'DataizePhi' <$> commandParser.dataize) (progDesc "Dataize a PHI program.")- , report = info (CLI'ReportPhi' <$> commandParser.report) (progDesc "Generate reports about initial and normalized PHI programs.")+ , printRules = info (CLI'PrintRules' <$> commandParser.printRules) (progDesc "Print rules in LaTeX format.") , pipeline = info (CLI'Pipeline' <$> commandParser.pipeline) (progDesc "Run pipeline-related commands.")- , pipelinePrepareTests = info commandParser.pipelinePrepareTests (progDesc "Prepare EO test files for the pipeline.")- , pipelinePrintDataizeConfigs = info commandParser.pipelinePrintDataizeConfigs (progDesc "Print configs for the `normalizer dataize` command.")+ , pipeline' =+ CommandParserInfo'Pipeline+ { report = info (CLI'Pipeline'Report' <$> commandParser.pipeline'.report) (progDesc "Generate reports about initial and normalized PHI programs.")+ , prepareTests = info (CLI'Pipeline'PrepareTests' <$> commandParser.pipeline'.prepareTests) (progDesc "Prepare EO test files for the pipeline.")+ , printDataizeConfigs = info (CLI'Pipeline'PrintDataizeConfigs' <$> commandParser.pipeline'.printDataizeConfigs) (progDesc [fmt|Print configs for the `normalizer {commandNames.dataize}` command.|])+ } } +data CommandNames'Pipeline = CommandNames'Pipeline+ { report :: String+ , prepareTests :: String+ , printDataizeConfigs :: String+ }+ data CommandNames = CommandNames { transform :: String , metrics :: String , dataize :: String- , report :: String+ , printRules :: String , pipeline :: String- , pipelinePrepareTests :: String- , pipelinePrintDataizeConfigs :: String+ , pipeline' :: CommandNames'Pipeline } commandNames :: CommandNames@@ -309,10 +355,14 @@ { transform = "transform" , metrics = "metrics" , dataize = "dataize"- , report = "report"+ , printRules = "print-rules" , pipeline = "pipeline"- , pipelinePrepareTests = "prepare-tests"- , pipelinePrintDataizeConfigs = "print-dataize-configs"+ , pipeline' =+ CommandNames'Pipeline+ { report = "report"+ , prepareTests = "prepare-tests"+ , printDataizeConfigs = "print-dataize-configs"+ } } cli :: Parser CLI@@ -321,8 +371,8 @@ ( command commandNames.transform commandParserInfo.transform <> command commandNames.metrics commandParserInfo.metrics <> command commandNames.dataize commandParserInfo.dataize- <> command commandNames.report commandParserInfo.report <> command commandNames.pipeline commandParserInfo.pipeline+ <> command commandNames.printRules commandParserInfo.printRules ) cliOpts :: ParserInfo CLI@@ -385,7 +435,7 @@ getLoggers :: Maybe FilePath -> IO (String -> IO (), String -> IO ()) getLoggers outputFile = do- handle <- maybe (pure stdout) (`openFile` WriteMode) outputFile+ handle <- maybe (pure stdout) (\file -> createDirectoryIfMissing True (takeDirectory file) >> openFile file WriteMode) outputFile pure ( \x -> hPutStrLn handle x >> hFlush handle , \x -> hPutStr handle x >> hFlush handle@@ -480,6 +530,11 @@ -- logStrLn "Computing metrics" metrics <- getMetrics bindingsPath inputFile logStrLn $ encodeToJSONString metrics+ CLI'PrintRules' CLI'PrintRules{..} -> do+ (logStrLn, _) <- getLoggers Nothing+ rules <- rules <$> maybe (return yegorRuleSet) parseRuleSetFromFile rulesPath+ let toLatex' = if compact then rulesToLatexCompact else toLatex+ logStrLn $ show $ toLatex' rules CLI'TransformPhi' CLI'TransformPhi{..} -> do program' <- getProgram inputFile deps <- mapM (getProgram . Just) dependencies@@ -564,7 +619,8 @@ (defaultContext rules (Formation bindingsWithDeps)) -- IMPORTANT: context contains dependencies! { minimizeTerms = minimizeStuckTerms , builtinRules = builtin- , enabledAtomNames = mkEnabledAtomNames disabledAtomNames enabledAtomNames+ , enabledAtoms = mkEnabledAtoms enabledAtomNames disabledAtomNames+ , knownAtoms = knownAtomsMap } if chain then do@@ -601,7 +657,7 @@ | otherwise = obj' in logStrLn (printAsProgramOrAsObject obj'') Right (Bytes bytes) -> logStrLn bytes- CLI'ReportPhi' CLI'ReportPhi{..} -> do+ CLI'Pipeline' (CLI'Pipeline'Report' CLI'Pipeline'Report{..}) -> do pipelineConfig <- decodeFileThrow @_ @PipelineConfig configFile let testSets = filter (fromMaybe True . (.enable)) pipelineConfig.testSets programReports <- forM (zip [1 ..] testSets) $ \(index :: Int, (.phi) -> testSet) -> do@@ -631,9 +687,9 @@ $ \(path, reportString) -> do createDirectoryIfMissing True (takeDirectory path) writeFile path reportString- CLI'Pipeline' CLI'Pipeline'PrepareTests{..} -> do+ CLI'Pipeline' (CLI'Pipeline'PrepareTests' CLI'Pipeline'PrepareTests{..}) -> do config <- decodeFileThrow @_ @PipelineConfig configFile- prepareTests config- CLI'Pipeline' CLI'Pipeline'PrintDataizeConfigs{..} -> do+ PrepareTests.prepareTests config+ CLI'Pipeline' (CLI'Pipeline'PrintDataizeConfigs' CLI'Pipeline'PrintDataizeConfigs{..}) -> do config <- decodeFileThrow @_ @PipelineConfig configFile- printDataizeConfigs config phiPrefixesToStrip singleLine+ PrintConfigs.printDataizeConfigs config phiPrefixesToStrip singleLine
+ data/0.36.0/dependencies.md view
@@ -0,0 +1,1994 @@+# Dependencies++## [org/eolang/as-phi.phi](./org/eolang/as-phi.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ as-phi ↦ ⟦+ λ ⤍ Lorg_eolang_as_phi,+ x ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/bool.phi](./org/eolang/bool.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ bool ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ not ↦ ⟦+ φ ↦ ξ.σ.σ.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ ).eq(+ α0 ↦ ξ.ρ+ )+ ⟧,+ and ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.ρ,+ α1 ↦ Φ.org.eolang.if(+ α0 ↦ ξ.x,+ α1 ↦ ξ.σ.σ.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ ),+ α2 ↦ ξ.σ.σ.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ),+ α2 ↦ ξ.σ.σ.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ )+ ⟧,+ or ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.σ.σ.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ ),+ α2 ↦ Φ.org.eolang.if(+ α0 ↦ ξ.x,+ α1 ↦ ξ.σ.σ.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ ),+ α2 ↦ ξ.σ.σ.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/bytes.phi](./org/eolang/bytes.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ bytes ↦ ⟦+ eq ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_eq,+ x ↦ ∅+ ⟧,+ size ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_size+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧,+ as-string ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_as_string+ ⟧,+ as-int ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_as_int+ ⟧,+ as-float ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_as_float+ ⟧,+ and ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_and,+ b ↦ ∅+ ⟧,+ or ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_or,+ b ↦ ∅+ ⟧,+ xor ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_xor,+ b ↦ ∅+ ⟧,+ not ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_not+ ⟧,+ left ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.right(+ α0 ↦ ξ.x.neg+ )+ ⟧,+ right ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_right,+ x ↦ ∅+ ⟧,+ as-bool ↦ ⟦+ φ ↦ ξ.ρ.eq(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ )+ ⟧,+ as-bytes ↦ ⟦+ φ ↦ ξ.ρ+ ⟧,+ concat ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_concat,+ b ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cage.phi](./org/eolang/cage.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cage ↦ ⟦+ object ↦ ∅,+ new ↦ ξ.φ.self,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_φ+ ⟧,+ encaged ↦ ⟦+ locator ↦ ∅,+ self ↦ ξ,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_φ+ ⟧,+ encage ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_encage,+ object ↦ ∅+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cti.phi](./org/eolang/cti.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cti ↦ ⟦+ delegate ↦ ∅,+ level ↦ ∅,+ message ↦ ∅,+ φ ↦ ξ.delegate+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/dataized.phi](./org/eolang/dataized.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ dataized ↦ ⟦+ λ ⤍ Lorg_eolang_dataized,+ target ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/error.phi](./org/eolang/error.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ error ↦ ⟦+ λ ⤍ Lorg_eolang_error,+ message ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/float.phi](./org/eolang/float.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ float ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ x-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ self-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ+ ).as-bytes,+ nan-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.nan+ ).as-bytes,+ pos-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ neg-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ )+ ),+ α1 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ ),+ α2 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ ).and(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ )+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.x-as-bytes+ )+ )+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_float_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_float_times,+ x ↦ ∅+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_float_plus,+ x ↦ ∅+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ )+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ )+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_float_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/go.phi](./org/eolang/go.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ go ↦ ⟦+ id ↦ Φ.org.eolang.malloc(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ ).id.as-bytes,+ to ↦ ⟦+ body ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ξ.body(+ α0 ↦ ξ.token+ ),+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.σ.ρ.id.eq(+ α0 ↦ ξ.e.id+ ),+ α1 ↦ ξ.e.value,+ α2 ↦ Φ.org.eolang.error(+ α0 ↦ ξ.e+ )+ )+ ⟧,+ α2 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ )+ ),+ token ↦ ⟦+ backward ↦ Φ.org.eolang.error(+ α0 ↦ ⟦+ value ↦ ξ.σ.ρ.ρ.to(+ α0 ↦ ξ.σ.ρ.body+ ),+ id ↦ ξ.σ.ρ.ρ.id+ ⟧+ ),+ forward ↦ ⟦+ res ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ ⟦+ value ↦ ξ.σ.res,+ id ↦ ξ.σ.ρ.ρ.ρ.id+ ⟧+ )+ ⟧+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/goto.phi](./org/eolang/goto.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ goto ↦ ⟦+ λ ⤍ Lambda,+ f ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/heap.phi](./org/eolang/heap.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ heap ↦ ⟦+ size ↦ ∅,+ malloc ↦ ⟦+ s ↦ ∅,+ next ↦ Φ.org.eolang.memory(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ new-next ↦ ξ.s.plus(+ α0 ↦ ξ.ρ.malloc.next.as-int+ ),+ φ ↦ ξ.new-next.gt(+ α0 ↦ ξ.σ.size+ ).if(+ α0 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 41-6C-6C-6F-63-61-74-69-6F-6E-20-66-61-69-6C-65-64-3A-20-62-61-64-20-61-6C-6C-6F-63-20-28-6E-6F-74-20-65-6E-6F-75-67-68-20-6D-65-6D-6F-72-79-20-69-6E-20-74-68-65-20-68-65-61-70-29+ )+ )+ ),+ α1 ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.ρ.malloc.next.write(+ α0 ↦ ξ.new-next+ )+ ),+ α1 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).plus(+ α0 ↦ ξ.ρ.malloc.next.as-int+ )+ )+ )+ )+ ⟧,+ free ↦ ⟦+ p ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.p+ ),+ α1 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ )+ )+ )+ ⟧,+ pointer ↦ ⟦+ address ↦ ∅,+ length ↦ ∅,+ φ ↦ ξ.address,+ add ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.ρ.pointer(+ α0 ↦ ξ.σ.address.plus(+ α0 ↦ ξ.σ.length.times(+ α0 ↦ ξ.x+ )+ ),+ α1 ↦ ξ.σ.length+ )+ ⟧,+ sub ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.add(+ α0 ↦ ξ.x.times(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ )+ ⟧,+ block ↦ ⟦+ λ ⤍ Lambda,+ len ↦ ∅,+ inverse ↦ ∅+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/if.phi](./org/eolang/if.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ if ↦ ⟦+ λ ⤍ Lorg_eolang_if,+ condition ↦ ∅,+ left ↦ ∅,+ right ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/int.phi](./org/eolang/int.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ int ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.σ.σ.int(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_int_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.σ.σ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_int_plus,+ x ↦ ∅+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ )+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_int_times,+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_int_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdin.phi](./org/eolang/io/stdin.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdin ↦ ⟦+ next-line ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_next_line+ ⟧,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_φ+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdout.phi](./org/eolang/io/stdout.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdout ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdout,+ text ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/malloc.phi](./org/eolang/malloc.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ malloc ↦ ⟦+ size ↦ ∅,+ pointer ↦ ξ.φ.pointer,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_φ+ ⟧,+ memory-block-pointer ↦ ⟦+ id ↦ ∅,+ pointer ↦ ξ,+ size ↦ ξ.ρ.size,+ read ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_memory_block_pointer_read,+ offset ↦ ∅,+ length ↦ ∅+ ⟧,+ write ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_memory_block_pointer_write,+ offset ↦ ∅,+ data ↦ ∅+ ⟧,+ free ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_memory_block_pointer_free+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/memory.phi](./org/eolang/memory.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ memory ↦ ⟦+ data ↦ ∅,+ alloc ↦ ξ.φ.alloc,+ φ ↦ ⟦+ bts ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.data+ ).as-bytes,+ p ↦ Φ.org.eolang.malloc(+ α0 ↦ ξ.bts.size+ ).pointer,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.p.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.bts+ )+ ),+ α1 ↦ ξ.ρ.allocated(+ α0 ↦ ξ.p+ )+ )+ )+ ⟧,+ allocated ↦ ⟦+ pointer ↦ ∅,+ alloc ↦ ξ,+ φ ↦ ξ.pointer.read(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.pointer.size+ ),+ write ↦ ⟦+ data ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.ρ.pointer.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.data+ )+ ),+ α1 ↦ ξ.ρ.pointer.read(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.ρ.pointer.size+ )+ )+ )+ ⟧,+ free ↦ ⟦+ φ ↦ ξ.ρ.pointer.free+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/nan.phi](./org/eolang/nan.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ nan ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.σ+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/negative-infinity.phi](./org/eolang/negative-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ negative-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.σ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ )+ ⟧,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ),+ α1 ↦ ξ.σ.σ.negative-infinity,+ α2 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.positive-infinity.as-bytes+ ).as-bytes,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ ξ.σ.σ.negative-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ ξ.σ.σ.negative-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.σ.σ.σ.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ),+ α1 ↦ ξ.σ.σ.negative-infinity,+ α2 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/nop.phi](./org/eolang/nop.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ nop ↦ ⟦+ args ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ )+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/positive-infinity.phi](./org/eolang/positive-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ positive-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 3F-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.σ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ),+ α1 ↦ ξ.σ.σ.positive-infinity,+ α2 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ ξ.σ.σ.positive-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.positive-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ ξ.σ.σ.positive-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.σ.σ.σ.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ),+ α1 ↦ Φ.org.eolang.nan,+ α2 ↦ Φ.org.eolang.if(+ α0 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ),+ α1 ↦ ξ.σ.σ.positive-infinity,+ α2 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/ram.phi](./org/eolang/ram.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ ram ↦ ⟦+ size ↦ ∅,+ write ↦ ⟦+ λ ⤍ Lambda,+ position ↦ ∅,+ data ↦ ∅+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lambda,+ position ↦ ∅,+ size ↦ ∅+ ⟧,+ ram-slice ↦ ⟦+ position ↦ ∅,+ size ↦ ∅,+ φ ↦ ⟦+ λ ⤍ Lambda+ ⟧,+ write ↦ ⟦+ λ ⤍ Lambda,+ data ↦ ∅+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/rust.phi](./org/eolang/rust.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ rust ↦ ⟦+ λ ⤍ Lorg_eolang_rust,+ code ↦ ∅,+ portal ↦ ∅,+ params ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/seq.phi](./org/eolang/seq.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ seq ↦ ⟦+ λ ⤍ Lorg_eolang_seq,+ steps ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/string.phi](./org/eolang/string.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ string ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ length ↦ ⟦+ λ ⤍ Lorg_eolang_string_length+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_string_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/switch.phi](./org/eolang/switch.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ switch ↦ ⟦+ cases ↦ ∅,+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.cases.length+ ).as-bytes,+ case-at ↦ ⟦+ index ↦ ∅,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.index.eq(+ α0 ↦ ξ.ρ.len+ ),+ α1 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ ),+ α2 ↦ Φ.org.eolang.if(+ α0 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ α1 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ ),+ α2 ↦ ξ.ρ.case-at(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ case ↦ ξ.ρ.cases.at(+ α0 ↦ ξ.index+ )+ ⟧,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.len.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 73-77-69-74-63-68-20-63-61-73-65-73-20-61-72-65-20-65-6D-70-74-79+ )+ )+ ),+ α2 ↦ ξ.case-at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/try.phi](./org/eolang/try.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ try ↦ ⟦+ λ ⤍ Lorg_eolang_try,+ main ↦ ∅,+ catch ↦ ∅,+ finally ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/tuple.phi](./org/eolang/tuple.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ tuple ↦ ⟦+ head ↦ ∅,+ tail ↦ ∅,+ empty ↦ ⟦+ at ↦ ⟦+ i ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-67-65-74-20-61-6E-20-6F-62-6A-65-63-74-20-66-72-6F-6D-20-74-68-65-20-65-6D-70-74-79-20-74-75-70-6C-65+ )+ )+ )+ ⟧,+ with ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.σ.tuple(+ α0 ↦ ξ.σ.σ.σ.tuple.empty,+ α1 ↦ ξ.x+ )+ ⟧,+ length ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ⟧,+ length ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ ξ.len+ ),+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.head.length.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ).as-bytes+ ⟧,+ at ↦ ⟦+ i ↦ ∅,+ len ↦ ξ.ρ.length,+ index ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.if(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.idx+ ),+ α1 ↦ ξ.len.plus(+ α0 ↦ ξ.idx+ ),+ α2 ↦ ξ.idx+ )+ ).as-bytes,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.index+ ).or(+ α0 ↦ ξ.len.lte(+ α0 ↦ ξ.index+ )+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 47-69-76-65-6E-20-69-6E-64-65-78-20-69-73-20-6F-75-74-20-6F-66-20-74-75-70-6C-65-20-62-6F-75-6E-64-73+ )+ )+ ),+ α2 ↦ ξ.at-fast(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.len+ )+ ),+ at-fast ↦ ⟦+ tup ↦ ∅,+ len ↦ ∅,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ ).gt(+ α0 ↦ ξ.ρ.index+ ),+ α1 ↦ ξ.ρ.at-fast(+ α0 ↦ ξ.tup.head,+ α1 ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ),+ α2 ↦ ξ.tup.tail+ )+ ⟧,+ idx ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.i+ ).as-bytes+ ⟧,+ with ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.tuple(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.x+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/while.phi](./org/eolang/while.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ while ↦ ⟦+ condition ↦ ∅,+ body ↦ ∅,+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.condition,+ α1 ↦ ξ.start(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ α2 ↦ Φ.org.eolang.bool(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ )+ )+ ),+ start ↦ ⟦+ index ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.ρ.body(+ α0 ↦ ξ.index+ )+ ),+ α1 ↦ ξ.ρ.loop(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ )+ ⟧,+ loop ↦ ⟦+ index ↦ ∅,+ current ↦ ξ.ρ.body(+ α0 ↦ ξ.index+ ),+ φ ↦ Φ.org.eolang.if(+ α0 ↦ ξ.ρ.condition,+ α1 ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.current+ ),+ α1 ↦ ξ.ρ.loop(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ α2 ↦ ξ.current+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```+
+ data/0.37.0/dependencies.md view
@@ -0,0 +1,1714 @@+# Dependencies++## [org/eolang/as-phi.phi](./org/eolang/as-phi.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ as-phi ↦ ⟦+ λ ⤍ Lorg_eolang_as_phi,+ x ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/bytes.phi](./org/eolang/bytes.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ bytes ↦ ⟦+ Δ ⤍ ∅,+ eq ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_eq,+ b ↦ ∅+ ⟧,+ size ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_size+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧,+ as-string ↦ ⟦+ φ ↦ Φ.org.eolang.string(+ α0 ↦ ξ.ρ+ )+ ⟧,+ as-int ↦ ⟦+ φ ↦ ξ.ρ.size.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ ξ.ρ+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-63-6F-6E-76-65-72-74-20-6E-6F-6E-20-38-20-6C-65-6E-67-74-68-20-62-79-74-65-73-20-74-6F-20-69-6E-74+ )+ )+ )+ )+ ⟧,+ as-float ↦ ⟦+ φ ↦ ξ.ρ.size.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ ξ.ρ+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-63-6F-6E-76-65-72-74-20-6E-6F-6E-20-38-20-6C-65-6E-67-74-68-20-62-79-74-65-73-20-74-6F-20-66-6C-6F-61-74+ )+ )+ )+ )+ ⟧,+ and ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_and,+ b ↦ ∅+ ⟧,+ or ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_or,+ b ↦ ∅+ ⟧,+ xor ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_xor,+ b ↦ ∅+ ⟧,+ not ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_not+ ⟧,+ left ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.right(+ α0 ↦ ξ.x.neg+ )+ ⟧,+ right ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_right,+ x ↦ ∅+ ⟧,+ as-bool ↦ ⟦+ φ ↦ ξ.ρ.eq(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ )+ ⟧,+ as-bytes ↦ ⟦+ φ ↦ ξ.ρ+ ⟧,+ concat ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_concat,+ b ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cage.phi](./org/eolang/cage.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cage ↦ ⟦+ object ↦ ∅,+ new ↦ ξ.φ.self,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_φ+ ⟧,+ encaged ↦ ⟦+ locator ↦ ∅,+ self ↦ ξ,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_φ+ ⟧,+ encage ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_encage,+ object ↦ ∅+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cti.phi](./org/eolang/cti.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cti ↦ ⟦+ delegate ↦ ∅,+ level ↦ ∅,+ message ↦ ∅,+ φ ↦ ξ.delegate+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/dataized.phi](./org/eolang/dataized.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ dataized ↦ ⟦+ λ ⤍ Lorg_eolang_dataized,+ target ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/error.phi](./org/eolang/error.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ error ↦ ⟦+ λ ⤍ Lorg_eolang_error,+ message ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/false.phi](./org/eolang/false.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ false ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ ),+ not ↦ Φ.org.eolang.true,+ if ↦ ⟦+ left ↦ ∅,+ right ↦ ∅,+ φ ↦ ξ.right+ ⟧,+ and ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ+ ⟧,+ or ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ).eq(+ α0 ↦ ξ.x+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/float.phi](./org/eolang/float.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ float ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ x-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ self-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ+ ).as-bytes,+ nan-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.nan+ ).as-bytes,+ pos-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ neg-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ φ ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.false,+ α1 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ ).and(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ )+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.x-as-bytes+ )+ )+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_float_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_float_times,+ x ↦ ∅+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_float_plus,+ x ↦ ∅+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.σ.σ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ )+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ )+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_float_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/go.phi](./org/eolang/go.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ go ↦ ⟦+ id ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.malloc.of(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ ),+ α1 ↦ ⟦+ φ ↦ ξ.m.put(+ α0 ↦ ξ.m.id+ ),+ m ↦ ∅+ ⟧+ )+ ).as-bytes,+ to ↦ ⟦+ body ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ξ.body(+ α0 ↦ ξ.token+ ),+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ ξ.σ.ρ.id.eq(+ α0 ↦ ξ.e.id+ ).if(+ α0 ↦ ξ.e.value,+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ ξ.e+ )+ )+ ⟧,+ α2 ↦ Φ.org.eolang.true+ ),+ token ↦ ⟦+ backward ↦ Φ.org.eolang.error(+ α0 ↦ ⟦+ value ↦ ξ.σ.ρ.ρ.to(+ α0 ↦ ξ.σ.ρ.body+ ),+ id ↦ ξ.σ.ρ.ρ.id+ ⟧+ ),+ forward ↦ ⟦+ res ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ ⟦+ value ↦ ξ.σ.res,+ id ↦ ξ.σ.ρ.ρ.ρ.id+ ⟧+ )+ ⟧+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/int.phi](./org/eolang/int.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ int ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.σ.σ.int(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_int_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.σ.σ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_int_plus,+ x ↦ ∅+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ )+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_int_times,+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_int_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdin.phi](./org/eolang/io/stdin.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdin ↦ ⟦+ next-line ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_next_line+ ⟧,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_φ+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdout.phi](./org/eolang/io/stdout.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdout ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdout,+ text ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/malloc.phi](./org/eolang/malloc.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ malloc ↦ ⟦+ for ↦ ⟦+ object ↦ ∅,+ scope ↦ ∅,+ bts ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.object+ ).as-bytes,+ φ ↦ ξ.σ.of(+ α0 ↦ ξ.bts.size,+ α1 ↦ ⟦+ m ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.m.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.σ.bts+ )+ ),+ α1 ↦ ξ.σ.scope(+ α0 ↦ ξ.m+ )+ )+ )+ ⟧+ )+ ⟧,+ of ↦ ⟦+ size ↦ ∅,+ scope ↦ ∅,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_φ+ ⟧,+ allocated ↦ ⟦+ id ↦ ∅,+ size ↦ ξ.ρ.size,+ φ ↦ ξ.get,+ read ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_allocated_read,+ offset ↦ ∅,+ length ↦ ∅+ ⟧,+ write ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_allocated_write,+ offset ↦ ∅,+ data ↦ ∅+ ⟧,+ get ↦ ⟦+ φ ↦ ξ.ρ.read(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.ρ.size+ )+ ⟧,+ put ↦ ⟦+ object ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.ρ.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.object+ )+ ),+ α1 ↦ ξ.ρ.get+ )+ )+ ⟧+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/nan.phi](./org/eolang/nan.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ nan ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.σ+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/negative-infinity.phi](./org/eolang/negative-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ negative-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.σ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.false+ )+ ⟧,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ φ ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.σ.σ.negative-infinity,+ α1 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.positive-infinity.as-bytes+ ).as-bytes,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.σ.σ.negative-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.σ.σ.negative-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.σ.σ.σ.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.false+ )+ ⟧,+ φ ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.σ.σ.negative-infinity,+ α1 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/positive-infinity.phi](./org/eolang/positive-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ positive-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 3F-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.σ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.false+ )+ ⟧,+ φ ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.σ.σ.positive-infinity,+ α1 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.σ.σ.positive-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.σ.σ.positive-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.σ.σ.positive-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.σ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.σ.σ.σ.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α1 ↦ ⟦+ e ↦ ∅,+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.σ.num+ )+ ⟧,+ α2 ↦ Φ.org.eolang.false+ )+ ⟧,+ φ ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.σ.σ.positive-infinity,+ α1 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/rust.phi](./org/eolang/rust.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ rust ↦ ⟦+ λ ⤍ Lorg_eolang_rust,+ code ↦ ∅,+ portal ↦ ∅,+ params ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/seq.phi](./org/eolang/seq.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ seq ↦ ⟦+ λ ⤍ Lorg_eolang_seq,+ steps ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/string.phi](./org/eolang/string.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ string ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ length ↦ ⟦+ λ ⤍ Lorg_eolang_string_length+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_string_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/switch.phi](./org/eolang/switch.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ switch ↦ ⟦+ cases ↦ ∅,+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.cases.length+ ).as-bytes,+ case-at ↦ ⟦+ index ↦ ∅,+ φ ↦ ξ.index.eq(+ α0 ↦ ξ.ρ.len+ ).if(+ α0 ↦ Φ.org.eolang.true,+ α1 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).if(+ α0 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ ),+ α1 ↦ ξ.ρ.case-at(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ case ↦ ξ.ρ.cases.at(+ α0 ↦ ξ.index+ )+ ⟧,+ φ ↦ ξ.len.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 73-77-69-74-63-68-20-63-61-73-65-73-20-61-72-65-20-65-6D-70-74-79+ )+ )+ ),+ α1 ↦ ξ.case-at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/true.phi](./org/eolang/true.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ true ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ),+ not ↦ Φ.org.eolang.false,+ if ↦ ⟦+ left ↦ ∅,+ right ↦ ∅,+ φ ↦ ξ.left+ ⟧,+ and ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ).eq(+ α0 ↦ ξ.x+ )+ ⟧,+ or ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/try.phi](./org/eolang/try.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ try ↦ ⟦+ λ ⤍ Lorg_eolang_try,+ main ↦ ∅,+ catch ↦ ∅,+ finally ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/tuple.phi](./org/eolang/tuple.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ tuple ↦ ⟦+ head ↦ ∅,+ tail ↦ ∅,+ empty ↦ ⟦+ at ↦ ⟦+ i ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-67-65-74-20-61-6E-20-6F-62-6A-65-63-74-20-66-72-6F-6D-20-74-68-65-20-65-6D-70-74-79-20-74-75-70-6C-65+ )+ )+ )+ ⟧,+ with ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.σ.tuple(+ α0 ↦ ξ.σ.σ.σ.tuple.empty,+ α1 ↦ ξ.x+ )+ ⟧,+ length ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ⟧,+ length ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ ξ.len+ ),+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.head.length.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ).as-bytes+ ⟧,+ at ↦ ⟦+ i ↦ ∅,+ len ↦ ξ.ρ.length,+ index ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.idx+ ).if(+ α0 ↦ ξ.len.plus(+ α0 ↦ ξ.idx+ ),+ α1 ↦ ξ.idx+ )+ ).as-bytes,+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.index+ ).or(+ α0 ↦ ξ.len.lte(+ α0 ↦ ξ.index+ )+ ).if(+ α0 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 47-69-76-65-6E-20-69-6E-64-65-78-20-69-73-20-6F-75-74-20-6F-66-20-74-75-70-6C-65-20-62-6F-75-6E-64-73+ )+ )+ ),+ α1 ↦ ξ.at-fast(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.len+ )+ ),+ at-fast ↦ ⟦+ tup ↦ ∅,+ len ↦ ∅,+ φ ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ ).gt(+ α0 ↦ ξ.ρ.index+ ).if(+ α0 ↦ ξ.ρ.at-fast(+ α0 ↦ ξ.tup.head,+ α1 ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ),+ α1 ↦ ξ.tup.tail+ )+ ⟧,+ idx ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.i+ ).as-bytes+ ⟧,+ with ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.σ.σ.tuple(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.x+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/while.phi](./org/eolang/while.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ while ↦ ⟦+ condition ↦ ∅,+ body ↦ ∅,+ φ ↦ ξ.condition.as-bool.if(+ α0 ↦ ξ.start(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ α1 ↦ Φ.org.eolang.false+ ),+ start ↦ ⟦+ index ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.ρ.body(+ α0 ↦ ξ.index+ )+ ),+ α1 ↦ ξ.ρ.loop(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ )+ ⟧,+ loop ↦ ⟦+ index ↦ ∅,+ current ↦ ξ.ρ.body(+ α0 ↦ ξ.index+ ),+ φ ↦ ξ.ρ.condition.as-bool.if(+ α0 ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.current+ ),+ α1 ↦ ξ.ρ.loop(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ α1 ↦ ξ.current+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```+
+ data/0.38.0/dependencies.md view
@@ -0,0 +1,1704 @@+# Dependencies++## [org/eolang/as-phi.phi](./org/eolang/as-phi.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ as-phi ↦ ⟦+ λ ⤍ Lorg_eolang_as_phi,+ x ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/bytes.phi](./org/eolang/bytes.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ bytes ↦ ⟦+ Δ ⤍ ∅,+ as-bytes ↦ ξ,+ eq ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_eq,+ b ↦ ∅+ ⟧,+ size ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_size+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧,+ as-string ↦ ⟦+ φ ↦ Φ.org.eolang.string(+ α0 ↦ ξ.ρ+ )+ ⟧,+ as-int ↦ ⟦+ φ ↦ ξ.ρ.size.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ ξ.ρ+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-63-6F-6E-76-65-72-74-20-6E-6F-6E-20-38-20-6C-65-6E-67-74-68-20-62-79-74-65-73-20-74-6F-20-69-6E-74+ )+ )+ )+ )+ ⟧,+ as-float ↦ ⟦+ φ ↦ ξ.ρ.size.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ ξ.ρ+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-63-6F-6E-76-65-72-74-20-6E-6F-6E-20-38-20-6C-65-6E-67-74-68-20-62-79-74-65-73-20-74-6F-20-66-6C-6F-61-74+ )+ )+ )+ )+ ⟧,+ and ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_and,+ b ↦ ∅+ ⟧,+ or ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_or,+ b ↦ ∅+ ⟧,+ xor ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_xor,+ b ↦ ∅+ ⟧,+ not ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_not+ ⟧,+ left ↦ ⟦+ φ ↦ ξ.ρ.right(+ α0 ↦ ξ.x.neg+ ),+ x ↦ ∅+ ⟧,+ right ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_right,+ x ↦ ∅+ ⟧,+ as-bool ↦ ⟦+ φ ↦ ξ.ρ.eq(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ )+ ⟧,+ concat ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_concat,+ b ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cage.phi](./org/eolang/cage.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cage ↦ ⟦+ object ↦ ∅,+ new ↦ ξ.φ.self,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_φ+ ⟧,+ encaged ↦ ⟦+ locator ↦ ∅,+ self ↦ ξ,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_φ+ ⟧,+ encage ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_encage,+ object ↦ ∅+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cti.phi](./org/eolang/cti.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cti ↦ ⟦+ φ ↦ ξ.delegate,+ delegate ↦ ∅,+ level ↦ ∅,+ message ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/dataized.phi](./org/eolang/dataized.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ dataized ↦ ⟦+ λ ⤍ Lorg_eolang_dataized,+ target ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/error.phi](./org/eolang/error.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ error ↦ ⟦+ λ ⤍ Lorg_eolang_error,+ message ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/false.phi](./org/eolang/false.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ false ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ ),+ not ↦ Φ.org.eolang.true,+ if ↦ ⟦+ φ ↦ ξ.right,+ left ↦ ∅,+ right ↦ ∅+ ⟧,+ and ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ or ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ).eq(+ α0 ↦ ξ.x+ ),+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/float.phi](./org/eolang/float.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ float ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ x-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ self-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ+ ).as-bytes,+ nan-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.nan+ ).as-bytes,+ pos-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ neg-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ φ ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.false,+ α1 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ ).and(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ )+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.x-as-bytes+ )+ )+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_float_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_float_times,+ x ↦ ∅+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_float_plus,+ x ↦ ∅+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ )+ )+ ⟧,+ minus ↦ ⟦+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ ),+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_float_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/go.phi](./org/eolang/go.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ go ↦ ⟦+ id ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.malloc.of(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ ),+ α1 ↦ ⟦+ φ ↦ ξ.m.put(+ α0 ↦ ξ.m.id+ ),+ m ↦ ∅+ ⟧+ )+ ).as-bytes,+ to ↦ ⟦+ body ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ξ.body(+ α0 ↦ ξ.token+ ),+ α1 ↦ ξ.auto-named-attr-at-64-9,+ α2 ↦ Φ.org.eolang.true+ ),+ token ↦ ⟦+ backward ↦ Φ.org.eolang.error(+ α0 ↦ ξ.jump(+ α0 ↦ ξ.ρ.ρ.to(+ α0 ↦ ξ.ρ.body+ )+ )+ ),+ jump ↦ ⟦+ value ↦ ∅,+ id ↦ ξ.ρ.ρ.ρ.id+ ⟧,+ forward ↦ ⟦+ res ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ ξ.ρ.jump(+ α0 ↦ ξ.res+ )+ )+ ⟧+ ⟧,+ auto-named-attr-at-64-9 ↦ ⟦+ e ↦ ∅,+ φ ↦ ξ.ρ.ρ.id.eq(+ α0 ↦ ξ.e.id+ ).if(+ α0 ↦ ξ.e.value,+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ ξ.e+ )+ )+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/int.phi](./org/eolang/int.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ int ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.ρ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.ρ.ρ.int(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_int_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.ρ.ρ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_int_plus,+ x ↦ ∅+ ⟧,+ minus ↦ ⟦+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ ),+ x ↦ ∅+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_int_times,+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_int_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdin.phi](./org/eolang/io/stdin.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdin ↦ ⟦+ next-line ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_next_line+ ⟧,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_φ+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdout.phi](./org/eolang/io/stdout.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdout ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdout,+ text ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/malloc.phi](./org/eolang/malloc.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ malloc ↦ ⟦+ for ↦ ⟦+ object ↦ ∅,+ scope ↦ ∅,+ bts ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.object+ ).as-bytes,+ φ ↦ ξ.ρ.ρ.malloc.of(+ α0 ↦ ξ.bts.size,+ α1 ↦ ξ.auto-named-attr-at-89-9+ ),+ auto-named-attr-at-89-9 ↦ ⟦+ m ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.m.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.ρ.bts+ )+ ),+ α1 ↦ ξ.ρ.scope(+ α0 ↦ ξ.m+ )+ )+ )+ ⟧+ ⟧,+ of ↦ ⟦+ size ↦ ∅,+ scope ↦ ∅,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_φ+ ⟧,+ allocated ↦ ⟦+ id ↦ ∅,+ size ↦ ξ.ρ.size,+ φ ↦ ξ.get,+ read ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_allocated_read,+ offset ↦ ∅,+ length ↦ ∅+ ⟧,+ write ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_allocated_write,+ offset ↦ ∅,+ data ↦ ∅+ ⟧,+ get ↦ ⟦+ φ ↦ ξ.ρ.read(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.ρ.size+ )+ ⟧,+ put ↦ ⟦+ object ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.ρ.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.object+ )+ ),+ α1 ↦ ξ.ρ.get+ )+ )+ ⟧+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/nan.phi](./org/eolang/nan.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ nan ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ lt ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ lte ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ gt ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ times ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ plus ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ+ ⟧,+ minus ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/negative-infinity.phi](./org/eolang/negative-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ negative-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-69-26,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-69-26 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ φ ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.negative-infinity,+ α1 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.positive-infinity.as-bytes+ ).as-bytes,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.negative-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.negative-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.ρ.ρ.ρ.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-136-27,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-136-27 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ φ ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.negative-infinity,+ α1 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/positive-infinity.phi](./org/eolang/positive-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ positive-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 3F-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-81-26,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-81-26 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ φ ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.positive-infinity,+ α1 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.positive-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.positive-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.positive-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.ρ.ρ.ρ.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-136-27,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-136-27 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ φ ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.positive-infinity,+ α1 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/rust.phi](./org/eolang/rust.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ rust ↦ ⟦+ λ ⤍ Lorg_eolang_rust,+ code ↦ ∅,+ portal ↦ ∅,+ params ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/seq.phi](./org/eolang/seq.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ seq ↦ ⟦+ λ ⤍ Lorg_eolang_seq,+ steps ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/string.phi](./org/eolang/string.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ string ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ length ↦ ⟦+ λ ⤍ Lorg_eolang_string_length+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_string_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/switch.phi](./org/eolang/switch.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ switch ↦ ⟦+ cases ↦ ∅,+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.cases.length+ ).as-bytes,+ case-at ↦ ⟦+ index ↦ ∅,+ φ ↦ ξ.index.eq(+ α0 ↦ ξ.ρ.len+ ).if(+ α0 ↦ Φ.org.eolang.true,+ α1 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).if(+ α0 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ ),+ α1 ↦ ξ.ρ.case-at(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ case ↦ ξ.ρ.cases.at(+ α0 ↦ ξ.index+ )+ ⟧,+ φ ↦ ξ.len.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 73-77-69-74-63-68-20-63-61-73-65-73-20-61-72-65-20-65-6D-70-74-79+ )+ )+ ),+ α1 ↦ ξ.case-at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/true.phi](./org/eolang/true.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ true ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ),+ not ↦ Φ.org.eolang.false,+ if ↦ ⟦+ φ ↦ ξ.left,+ left ↦ ∅,+ right ↦ ∅+ ⟧,+ and ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ).eq(+ α0 ↦ ξ.x+ ),+ x ↦ ∅+ ⟧,+ or ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/try.phi](./org/eolang/try.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ try ↦ ⟦+ λ ⤍ Lorg_eolang_try,+ main ↦ ∅,+ catch ↦ ∅,+ finally ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/tuple.phi](./org/eolang/tuple.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ tuple ↦ ⟦+ head ↦ ∅,+ tail ↦ ∅,+ empty ↦ ⟦+ length ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ at ↦ ⟦+ i ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-67-65-74-20-61-6E-20-6F-62-6A-65-63-74-20-66-72-6F-6D-20-74-68-65-20-65-6D-70-74-79-20-74-75-70-6C-65+ )+ )+ )+ ⟧,+ with ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.ρ.ρ.tuple(+ α0 ↦ ξ.ρ.ρ.ρ.tuple.empty,+ α1 ↦ ξ.x+ )+ ⟧+ ⟧,+ length ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ ξ.len+ ),+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.head.length.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ).as-bytes+ ⟧,+ at ↦ ⟦+ i ↦ ∅,+ len ↦ ξ.ρ.length,+ index ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.idx+ ).if(+ α0 ↦ ξ.len.plus(+ α0 ↦ ξ.idx+ ),+ α1 ↦ ξ.idx+ )+ ).as-bytes,+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.index+ ).or(+ α0 ↦ ξ.len.lte(+ α0 ↦ ξ.index+ )+ ).if(+ α0 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 47-69-76-65-6E-20-69-6E-64-65-78-20-69-73-20-6F-75-74-20-6F-66-20-74-75-70-6C-65-20-62-6F-75-6E-64-73+ )+ )+ ),+ α1 ↦ ξ.at-fast(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.len+ )+ ),+ at-fast ↦ ⟦+ tup ↦ ∅,+ len ↦ ∅,+ φ ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ ).gt(+ α0 ↦ ξ.ρ.index+ ).if(+ α0 ↦ ξ.ρ.at-fast(+ α0 ↦ ξ.tup.head,+ α1 ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ),+ α1 ↦ ξ.tup.tail+ )+ ⟧,+ idx ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.i+ ).as-bytes+ ⟧,+ with ↦ ⟦+ φ ↦ ξ.ρ.ρ.tuple(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.x+ ),+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/while.phi](./org/eolang/while.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ while ↦ ⟦+ condition ↦ ∅,+ body ↦ ∅,+ φ ↦ ξ.condition(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).as-bool.if(+ α0 ↦ ξ.loop(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ α1 ↦ Φ.org.eolang.false+ ),+ loop ↦ ⟦+ index ↦ ∅,+ current ↦ ξ.ρ.body(+ α0 ↦ ξ.index+ ),+ φ ↦ ξ.ρ.condition(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ).as-bool.if(+ α0 ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.current+ ),+ α1 ↦ ξ.ρ.loop(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ α1 ↦ ξ.current+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```+
+ data/0.38.4/dependencies.md view
@@ -0,0 +1,1755 @@+# Dependencies++## [org/eolang/as-phi.phi](./org/eolang/as-phi.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ as-phi ↦ ⟦+ λ ⤍ Lorg_eolang_as_phi,+ x ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/bytes.phi](./org/eolang/bytes.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ bytes ↦ ⟦+ Δ ⤍ ∅,+ as-bytes ↦ ξ,+ eq ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_eq,+ b ↦ ∅+ ⟧,+ size ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_size+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧,+ as-string ↦ ⟦+ φ ↦ Φ.org.eolang.string(+ α0 ↦ ξ.ρ+ )+ ⟧,+ as-int ↦ ⟦+ φ ↦ ξ.ρ.size.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ ξ.ρ+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-63-6F-6E-76-65-72-74-20-6E-6F-6E-20-38-20-6C-65-6E-67-74-68-20-62-79-74-65-73-20-74-6F-20-69-6E-74+ )+ )+ )+ )+ ⟧,+ as-float ↦ ⟦+ φ ↦ ξ.ρ.size.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ ξ.ρ+ ),+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-63-6F-6E-76-65-72-74-20-6E-6F-6E-20-38-20-6C-65-6E-67-74-68-20-62-79-74-65-73-20-74-6F-20-66-6C-6F-61-74+ )+ )+ )+ )+ ⟧,+ and ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_and,+ b ↦ ∅+ ⟧,+ or ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_or,+ b ↦ ∅+ ⟧,+ xor ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_xor,+ b ↦ ∅+ ⟧,+ not ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_not+ ⟧,+ left ↦ ⟦+ φ ↦ ξ.ρ.right(+ α0 ↦ ξ.x.neg+ ),+ x ↦ ∅+ ⟧,+ right ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_right,+ x ↦ ∅+ ⟧,+ as-bool ↦ ⟦+ φ ↦ ξ.ρ.eq(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ )+ )+ ⟧,+ concat ↦ ⟦+ λ ⤍ Lorg_eolang_bytes_concat,+ b ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cage.phi](./org/eolang/cage.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cage ↦ ⟦+ object ↦ ∅,+ new ↦ ξ.φ.self,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_φ+ ⟧,+ encaged ↦ ⟦+ locator ↦ ∅,+ self ↦ ξ,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_φ+ ⟧,+ encage ↦ ⟦+ λ ⤍ Lorg_eolang_cage_encaged_encage,+ object ↦ ∅+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/cti.phi](./org/eolang/cti.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ cti ↦ ⟦+ φ ↦ ξ.delegate,+ delegate ↦ ∅,+ level ↦ ∅,+ message ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/dataized.phi](./org/eolang/dataized.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ dataized ↦ ⟦+ λ ⤍ Lorg_eolang_dataized,+ target ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/error.phi](./org/eolang/error.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ error ↦ ⟦+ λ ⤍ Lorg_eolang_error,+ message ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/false.phi](./org/eolang/false.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ false ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-+ ),+ not ↦ Φ.org.eolang.true,+ if ↦ ⟦+ φ ↦ ξ.right,+ left ↦ ∅,+ right ↦ ∅+ ⟧,+ and ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ or ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ).eq(+ α0 ↦ ξ.x+ ),+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/float.phi](./org/eolang/float.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ float ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ x-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ self-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ+ ).as-bytes,+ nan-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.nan+ ).as-bytes,+ pos-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ neg-zero-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ ).as-bytes,+ φ ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.nan-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.false,+ α1 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.x-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ ).and(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.pos-zero-as-bytes+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.neg-zero-as-bytes+ )+ )+ ).or(+ α0 ↦ ξ.self-as-bytes.eq(+ α0 ↦ ξ.x-as-bytes+ )+ )+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_float_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ )+ )+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_float_times,+ x ↦ ∅+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_float_plus,+ x ↦ ∅+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.ρ.ρ.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ )+ )+ ⟧,+ minus ↦ ⟦+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ ),+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_float_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/go.phi](./org/eolang/go.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ go ↦ ⟦+ id ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.malloc.of(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-08+ )+ ),+ α1 ↦ ⟦+ φ ↦ ξ.m.put(+ α0 ↦ ξ.m.id+ ),+ m ↦ ∅+ ⟧+ )+ ).as-bytes,+ to ↦ ⟦+ body ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ ξ.body(+ α0 ↦ ξ.token+ ),+ α1 ↦ ξ.auto-named-attr-at-64-9,+ α2 ↦ Φ.org.eolang.true+ ),+ token ↦ ⟦+ backward ↦ Φ.org.eolang.error(+ α0 ↦ ξ.jump(+ α0 ↦ ξ.ρ.ρ.to(+ α0 ↦ ξ.ρ.body+ )+ )+ ),+ jump ↦ ⟦+ value ↦ ∅,+ id ↦ ξ.ρ.ρ.ρ.id+ ⟧,+ forward ↦ ⟦+ res ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ ξ.ρ.jump(+ α0 ↦ ξ.res+ )+ )+ ⟧+ ⟧,+ auto-named-attr-at-64-9 ↦ ⟦+ e ↦ ∅,+ φ ↦ ξ.ρ.ρ.id.eq(+ α0 ↦ ξ.e.id+ ).if(+ α0 ↦ ξ.e.value,+ α1 ↦ Φ.org.eolang.error(+ α0 ↦ ξ.e+ )+ )+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/int.phi](./org/eolang/int.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ int ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.ρ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.ρ.minus(+ α0 ↦ ξ.ρ.ρ.int(+ α0 ↦ ξ.value+ )+ )+ ),+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.gt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ gt ↦ ⟦+ λ ⤍ Lorg_eolang_int_gt,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.lt(+ α0 ↦ ξ.value+ ).not,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ.times(+ α0 ↦ ξ.ρ.ρ.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ⟧,+ plus ↦ ⟦+ λ ⤍ Lorg_eolang_int_plus,+ x ↦ ∅+ ⟧,+ minus ↦ ⟦+ φ ↦ ξ.ρ.plus(+ α0 ↦ ξ.x.neg+ ),+ x ↦ ∅+ ⟧,+ times ↦ ⟦+ λ ⤍ Lorg_eolang_int_times,+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ λ ⤍ Lorg_eolang_int_div,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdin.phi](./org/eolang/io/stdin.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdin ↦ ⟦+ next-line ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_next_line+ ⟧,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdin_φ+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/io/stdout.phi](./org/eolang/io/stdout.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ io ↦ ⟦+ stdout ↦ ⟦+ λ ⤍ Lorg_eolang_io_stdout,+ text ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/malloc.phi](./org/eolang/malloc.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ malloc ↦ ⟦+ for ↦ ⟦+ object ↦ ∅,+ scope ↦ ∅,+ bts ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.object+ ).as-bytes,+ φ ↦ ξ.ρ.ρ.malloc.of(+ α0 ↦ ξ.bts.size,+ α1 ↦ ξ.auto-named-attr-at-89-9+ ),+ auto-named-attr-at-89-9 ↦ ⟦+ m ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.m.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.ρ.bts+ )+ ),+ α1 ↦ ξ.ρ.scope(+ α0 ↦ ξ.m+ )+ )+ )+ ⟧+ ⟧,+ of ↦ ⟦+ size ↦ ∅,+ scope ↦ ∅,+ φ ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_φ+ ⟧,+ allocated ↦ ⟦+ id ↦ ∅,+ size ↦ ξ.ρ.size,+ φ ↦ ξ.get,+ read ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_allocated_read,+ offset ↦ ∅,+ length ↦ ∅+ ⟧,+ write ↦ ⟦+ λ ⤍ Lorg_eolang_malloc_of_allocated_write,+ offset ↦ ∅,+ data ↦ ∅+ ⟧,+ get ↦ ⟦+ φ ↦ ξ.ρ.read(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.ρ.size+ )+ ⟧,+ put ↦ ⟦+ object ↦ ∅,+ φ ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.ρ.write(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ α1 ↦ ξ.object+ )+ ),+ α1 ↦ ξ.ρ.get+ )+ )+ ⟧+ ⟧+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/nan.phi](./org/eolang/nan.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ nan ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ lt ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ lte ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ gt ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ gte ↦ ⟦+ φ ↦ Φ.org.eolang.false,+ x ↦ ∅+ ⟧,+ times ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ plus ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ neg ↦ ⟦+ φ ↦ ξ.ρ+ ⟧,+ minus ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧,+ div ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/negative-infinity.phi](./org/eolang/negative-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ negative-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ BF-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-69-26,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-69-26 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ φ ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.negative-infinity,+ α1 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.positive-infinity.as-bytes+ ).as-bytes,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.negative-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.negative-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.ρ.ρ.ρ.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-136-27,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-136-27 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ φ ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.negative-infinity,+ α1 ↦ Φ.org.eolang.positive-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/positive-infinity.phi](./org/eolang/positive-infinity.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ positive-infinity ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 3F-F0-00-00-00-00-00-00+ )+ ).div(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ lt ↦ ⟦+ x ↦ ∅,+ φ ↦ Φ.org.eolang.false+ ⟧,+ lte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.eq(+ α0 ↦ ξ.x+ )+ ⟧,+ gt ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ φ ↦ ξ.value.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).or(+ α0 ↦ ξ.ρ.eq(+ α0 ↦ ξ.value+ )+ ).not+ ⟧,+ gte ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.x.as-bytes.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ ).not+ ⟧,+ times ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 80-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ is-num-gt-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-81-26,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-81-26 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lt(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ φ ↦ ξ.is-nan-or-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gt-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.positive-infinity,+ α1 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ plus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ neg-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.negative-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.neg-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.positive-infinity+ )+ ⟧,+ minus ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ pos-inf-as-bytes ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.ρ.positive-infinity+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ φ ↦ ξ.is-nan(+ α0 ↦ ξ.value+ ).or(+ α0 ↦ ξ.value.eq(+ α0 ↦ ξ.pos-inf-as-bytes+ )+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.ρ.ρ.positive-infinity+ )+ ⟧,+ div ↦ ⟦+ x ↦ ∅,+ value ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.x+ ).as-bytes,+ is-nan ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.nan.as-bytes+ )+ ⟧,+ is-nan-or-infinite ↦ ⟦+ num ↦ ∅,+ φ ↦ ξ.ρ.is-nan(+ α0 ↦ ξ.num+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ ξ.ρ.ρ.ρ.positive-infinity+ )+ ).or(+ α0 ↦ ξ.num.eq(+ α0 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧,+ is-num-gte-zero ↦ ⟦+ num ↦ ∅,+ φ ↦ Φ.org.eolang.try(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.num+ ),+ α1 ↦ ξ.auto-named-attr-at-136-27,+ α2 ↦ Φ.org.eolang.false+ ),+ auto-named-attr-at-136-27 ↦ ⟦+ φ ↦ Φ.org.eolang.float(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).lte(+ α0 ↦ ξ.ρ.num+ ),+ e ↦ ∅+ ⟧+ ⟧,+ φ ↦ ξ.is-nan-or-infinite(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ Φ.org.eolang.nan,+ α1 ↦ ξ.is-num-gte-zero(+ α0 ↦ ξ.value+ ).if(+ α0 ↦ ξ.ρ.ρ.positive-infinity,+ α1 ↦ Φ.org.eolang.negative-infinity+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/rust.phi](./org/eolang/rust.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ rust ↦ ⟦+ λ ⤍ Lorg_eolang_rust,+ code ↦ ∅,+ portal ↦ ∅,+ params ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/seq.phi](./org/eolang/seq.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ seq ↦ ⟦+ steps ↦ ∅,+ φ ↦ ξ.steps.length.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.true,+ α1 ↦ ξ.loop(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ ),+ max-len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.steps.length.minus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ).as-bytes,+ loop ↦ ⟦+ index ↦ ∅,+ φ ↦ ξ.index.lt(+ α0 ↦ ξ.ρ.max-len+ ).and(+ α0 ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.steps.at(+ α0 ↦ ξ.index+ )+ ).as-bool.or(+ α0 ↦ Φ.org.eolang.true+ )+ ).if(+ α0 ↦ ξ.ρ.loop(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ),+ α1 ↦ ξ.ρ.steps.at(+ α0 ↦ ξ.index+ )+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/string.phi](./org/eolang/string.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ string ↦ ⟦+ as-bytes ↦ ∅,+ φ ↦ ξ.as-bytes,+ eq ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.as-bytes.eq(+ α0 ↦ ξ.x.as-bytes+ )+ ⟧,+ length ↦ ⟦+ λ ⤍ Lorg_eolang_string_length+ ⟧,+ slice ↦ ⟦+ λ ⤍ Lorg_eolang_string_slice,+ start ↦ ∅,+ len ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/switch.phi](./org/eolang/switch.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ switch ↦ ⟦+ cases ↦ ∅,+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.cases.length+ ).as-bytes,+ case-at ↦ ⟦+ index ↦ ∅,+ φ ↦ ξ.index.eq(+ α0 ↦ ξ.ρ.len+ ).if(+ α0 ↦ Φ.org.eolang.true,+ α1 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).if(+ α0 ↦ ξ.case.at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ ),+ α1 ↦ ξ.ρ.case-at(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ case ↦ ξ.ρ.cases.at(+ α0 ↦ ξ.index+ )+ ⟧,+ φ ↦ ξ.len.eq(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).if(+ α0 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 73-77-69-74-63-68-20-63-61-73-65-73-20-61-72-65-20-65-6D-70-74-79+ )+ )+ ),+ α1 ↦ ξ.case-at(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ )+ )+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/true.phi](./org/eolang/true.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ true ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ),+ not ↦ Φ.org.eolang.false,+ if ↦ ⟦+ φ ↦ ξ.left,+ left ↦ ∅,+ right ↦ ∅+ ⟧,+ and ↦ ⟦+ φ ↦ Φ.org.eolang.bytes(+ Δ ⤍ 01-+ ).eq(+ α0 ↦ ξ.x+ ),+ x ↦ ∅+ ⟧,+ or ↦ ⟦+ φ ↦ ξ.ρ,+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/try.phi](./org/eolang/try.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ try ↦ ⟦+ λ ⤍ Lorg_eolang_try,+ main ↦ ∅,+ catch ↦ ∅,+ finally ↦ ∅+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/tuple.phi](./org/eolang/tuple.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ tuple ↦ ⟦+ head ↦ ∅,+ tail ↦ ∅,+ empty ↦ ⟦+ length ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ),+ at ↦ ⟦+ i ↦ ∅,+ φ ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 43-61-6E-27-74-20-67-65-74-20-61-6E-20-6F-62-6A-65-63-74-20-66-72-6F-6D-20-74-68-65-20-65-6D-70-74-79-20-74-75-70-6C-65+ )+ )+ )+ ⟧,+ with ↦ ⟦+ x ↦ ∅,+ φ ↦ ξ.ρ.ρ.ρ.tuple(+ α0 ↦ ξ.ρ.ρ.ρ.tuple.empty,+ α1 ↦ ξ.x+ )+ ⟧+ ⟧,+ length ↦ ⟦+ φ ↦ Φ.org.eolang.int(+ α0 ↦ ξ.len+ ),+ len ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.ρ.head.length.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ).as-bytes+ ⟧,+ at ↦ ⟦+ i ↦ ∅,+ len ↦ ξ.ρ.length,+ index ↦ Φ.org.eolang.dataized(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.idx+ ).if(+ α0 ↦ ξ.len.plus(+ α0 ↦ ξ.idx+ ),+ α1 ↦ ξ.idx+ )+ ).as-bytes,+ φ ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ ).gt(+ α0 ↦ ξ.index+ ).or(+ α0 ↦ ξ.len.lte(+ α0 ↦ ξ.index+ )+ ).if(+ α0 ↦ Φ.org.eolang.error(+ α0 ↦ Φ.org.eolang.string(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 47-69-76-65-6E-20-69-6E-64-65-78-20-69-73-20-6F-75-74-20-6F-66-20-74-75-70-6C-65-20-62-6F-75-6E-64-73+ )+ )+ ),+ α1 ↦ ξ.at-fast(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.len+ )+ ),+ at-fast ↦ ⟦+ tup ↦ ∅,+ len ↦ ∅,+ φ ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ ).gt(+ α0 ↦ ξ.ρ.index+ ).if(+ α0 ↦ ξ.ρ.at-fast(+ α0 ↦ ξ.tup.head,+ α1 ↦ ξ.len.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ FF-FF-FF-FF-FF-FF-FF-FF+ )+ )+ )+ ),+ α1 ↦ ξ.tup.tail+ )+ ⟧,+ idx ↦ Φ.org.eolang.dataized(+ α0 ↦ ξ.i+ ).as-bytes+ ⟧,+ with ↦ ⟦+ φ ↦ ξ.ρ.ρ.tuple(+ α0 ↦ ξ.ρ,+ α1 ↦ ξ.x+ ),+ x ↦ ∅+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```++## [org/eolang/while.phi](./org/eolang/while.phi)++```console+{+ ⟦+ org ↦ ⟦+ eolang ↦ ⟦+ while ↦ ⟦+ condition ↦ ∅,+ body ↦ ∅,+ φ ↦ ξ.condition(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ).as-bool.if(+ α0 ↦ ξ.loop(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-00+ )+ )+ ),+ α1 ↦ Φ.org.eolang.false+ ),+ loop ↦ ⟦+ index ↦ ∅,+ current ↦ ξ.ρ.body(+ α0 ↦ ξ.index+ ),+ φ ↦ ξ.ρ.condition(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ ).as-bool.if(+ α0 ↦ Φ.org.eolang.seq(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple(+ α0 ↦ Φ.org.eolang.tuple.empty,+ α1 ↦ ξ.current+ ),+ α1 ↦ ξ.ρ.loop(+ α0 ↦ ξ.index.plus(+ α0 ↦ Φ.org.eolang.int(+ α0 ↦ Φ.org.eolang.bytes(+ Δ ⤍ 00-00-00-00-00-00-00-01+ )+ )+ )+ )+ )+ ),+ α1 ↦ ξ.current+ )+ ⟧+ ⟧,+ λ ⤍ Package+ ⟧,+ λ ⤍ Package+ ⟧+ ⟧+}+```+
eo-phi-normalizer.cabal view
@@ -1,11 +1,11 @@ cabal-version: 1.24 --- This file has been generated from package.yaml by hpack version 0.36.0.+-- This file has been generated from package.yaml by hpack version 0.37.0. -- -- see: https://github.com/sol/hpack name: eo-phi-normalizer-version: 1.0.0+version: 1.1.0 synopsis: Command line normalizer of 𝜑-calculus expressions. description: Please see the README on GitHub at <https://github.com/objectionary/eo-phi-normalizer#readme> homepage: https://github.com/objectionary/eo-phi-normalizer#readme@@ -22,6 +22,7 @@ grammar/EO/Phi/Syntax.cf report/main.js report/styles.css+ data/0.36.0/dependencies.md data/0.36.0/org/eolang/as-phi.phi data/0.36.0/org/eolang/bool.phi data/0.36.0/org/eolang/bytes.phi@@ -51,6 +52,7 @@ data/0.36.0/org/eolang/try.phi data/0.36.0/org/eolang/tuple.phi data/0.36.0/org/eolang/while.phi+ data/0.37.0/dependencies.md data/0.37.0/org/eolang/as-phi.phi data/0.37.0/org/eolang/bytes.phi data/0.37.0/org/eolang/cage.phi@@ -75,6 +77,7 @@ data/0.37.0/org/eolang/try.phi data/0.37.0/org/eolang/tuple.phi data/0.37.0/org/eolang/while.phi+ data/0.38.0/dependencies.md data/0.38.0/org/eolang/as-phi.phi data/0.38.0/org/eolang/bytes.phi data/0.38.0/org/eolang/cage.phi@@ -99,6 +102,7 @@ data/0.38.0/org/eolang/try.phi data/0.38.0/org/eolang/tuple.phi data/0.38.0/org/eolang/while.phi+ data/0.38.4/dependencies.md data/0.38.4/org/eolang/as-phi.phi data/0.38.4/org/eolang/bytes.phi data/0.38.4/org/eolang/cage.phi@@ -139,6 +143,8 @@ exposed-modules: Language.EO.Phi Language.EO.Phi.Dataize+ Language.EO.Phi.Dataize.Atoms+ Language.EO.Phi.Dataize.Context Language.EO.Phi.Dependencies Language.EO.Phi.Metrics.Collect Language.EO.Phi.Metrics.Data@@ -247,6 +253,8 @@ other-modules: Language.EO.Phi Language.EO.Phi.Dataize+ Language.EO.Phi.Dataize.Atoms+ Language.EO.Phi.Dataize.Context Language.EO.Phi.Dependencies Language.EO.Phi.Metrics.Collect Language.EO.Phi.Metrics.Data
src/Language/EO/Phi/Dataize.hs view
@@ -10,11 +10,7 @@ module Language.EO.Phi.Dataize where -import Data.Bits import Data.HashMap.Strict qualified as HashMap-import Data.HashSet (HashSet, difference, fromList)-import Data.HashSet qualified as HashSet-import Data.List (singleton) import Data.List.NonEmpty qualified as NonEmpty import Data.Maybe (listToMaybe) import Language.EO.Phi (printTree)@@ -32,9 +28,6 @@ dataizeStep' :: Context -> Object -> Either Object Bytes dataizeStep' ctx obj = snd (dataizeStep ctx obj) --- | State of evaluation is not needed yet, but it might be in the future-type EvaluationState = ()- -- | Recursively perform normalization and dataization until we get bytes in the end. dataizeRecursively :: Context -> Object -> Either Object Bytes dataizeRecursively ctx obj = snd $ dataizeRecursivelyChain' ctx obj@@ -53,7 +46,7 @@ | Just (LambdaBinding (Function funcName)) <- listToMaybe [b | b@(LambdaBinding _) <- bs] , not hasEmpty = do ctx' <- getContext- let lambaIsKnownAndNotEnabled = HashSet.member funcName knownAtomNames && not (HashSet.member funcName ctx'.enabledAtomNames)+ let lambaIsKnownAndNotEnabled = HashMap.member funcName ctx'.knownAtoms && not (HashMap.member funcName ctx'.enabledAtoms) if lambaIsKnownAndNotEnabled then do logStep [fmt|Not evaluating the lambda '{funcName}' since it's disabled.|] (Left obj)@@ -234,34 +227,6 @@ evaluateUnaryDataizationFunChain resultToBytes bytesToParam wrapBytes extractArg func = evaluateBinaryDataizationFunChain resultToBytes bytesToParam wrapBytes extractArg extractArg (const . func) -evaluateIODataizationFunChain :: IO String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState)-evaluateIODataizationFunChain action _obj state =- return (Formation [DeltaBinding (stringToBytes (unsafePerformIO action))], state)--extractRho :: Object -> Object-extractRho = (`ObjectDispatch` Rho)-extractAlpha0 :: Object -> Object-extractAlpha0 = (`ObjectDispatch` Alpha (AlphaIndex "α0"))-extractLabel :: String -> Object -> Object-extractLabel attrName = (`ObjectDispatch` Label (LabelId attrName))-wrapBytesInInt :: Bytes -> Object-wrapBytesInInt (Bytes bytes) = [fmt|Φ.org.eolang.int(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes}))|]-wrapBytesInFloat :: Bytes -> Object-wrapBytesInFloat (Bytes bytes) = [fmt|Φ.org.eolang.float(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes}))|]-wrapBytesInString :: Bytes -> Object-wrapBytesInString (Bytes bytes) = [fmt|Φ.org.eolang.string(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes}))|]-wrapBytesInBytes :: Bytes -> Object-wrapBytesInBytes (Bytes bytes) = [fmt|Φ.org.eolang.bytes(Δ ⤍ {bytes})|]-wrapTermination :: Object-wrapTermination = [fmt|Φ.org.eolang.error(α0 ↦ Φ.org.eolang.string(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes})))|]- where- Bytes bytes = stringToBytes "unknown error"--wrapBytesAsBool :: Bytes -> Object-wrapBytesAsBool bytes- | bytesToInt bytes == 0 = [fmt|Φ.org.eolang.false|]- | otherwise = [fmt|Φ.org.eolang.true|]- -- This should maybe get converted to a type class and some instances? evaluateIntIntIntFunChain :: (Int -> Int -> Int) -> String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState) evaluateIntIntIntFunChain = evaluateBinaryDataizationFunChain intToBytes bytesToInt wrapBytesInInt extractRho (extractLabel "x")@@ -279,128 +244,16 @@ evaluateFloatFloatFloatFunChain :: (Double -> Double -> Double) -> String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState) evaluateFloatFloatFloatFunChain = evaluateBinaryDataizationFunChain floatToBytes bytesToFloat wrapBytesInFloat extractRho (extractLabel "x") -knownAtoms :: [(String, String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState))]-knownAtoms =- [ ("Lorg_eolang_int_gt", evaluateIntIntBoolFunChain (>))- , ("Lorg_eolang_int_plus", evaluateIntIntIntFunChain (+))- , ("Lorg_eolang_int_times", evaluateIntIntIntFunChain (*))- , ("Lorg_eolang_int_div", evaluateIntIntIntFunChain quot)- , ("Lorg_eolang_bytes_eq", evaluateBinaryDataizationFunChain boolToBytes bytesToInt wrapBytesAsBool extractRho (extractLabel "b") (==))- ,- ( "Lorg_eolang_bytes_size"- , let f = evaluateUnaryDataizationFunChain intToBytes id wrapBytesInBytes extractRho (\(Bytes bytes) -> length (words (map dashToSpace bytes)))- where- dashToSpace '-' = ' '- dashToSpace c = c- in f- )- ,- ( "Lorg_eolang_bytes_slice"- , \name obj state -> do- thisStr <- incLogLevel $ dataizeRecursivelyChain True (extractRho obj)- bytes <- case thisStr of- Right bytes -> pure bytes- Left _ -> fail "Couldn't find bytes"- evaluateBinaryDataizationFunChain id bytesToInt wrapBytesInBytes (extractLabel "start") (extractLabel "len") (sliceBytes bytes) name obj state- )- , ("Lorg_eolang_bytes_and", evaluateBytesBytesBytesFunChain (.&.))- , ("Lorg_eolang_bytes_or", evaluateBytesBytesBytesFunChain (.|.))- , ("Lorg_eolang_bytes_xor", evaluateBytesBytesBytesFunChain (.^.))- , ("Lorg_eolang_bytes_not", evaluateBytesBytesFunChain complement)- , ("Lorg_eolang_bytes_right", evaluateBinaryDataizationFunChain intToBytes bytesToInt wrapBytesInBytes extractRho (extractLabel "x") (\x i -> shift x (-i)))- , ("Lorg_eolang_bytes_concat", evaluateBinaryDataizationFunChain id id wrapBytesInBytes extractRho (extractLabel "b") concatBytes)- , -- float- ("Lorg_eolang_float_gt", evaluateBinaryDataizationFunChain boolToBytes bytesToFloat wrapBytesInBytes extractRho (extractLabel "x") (>))- , ("Lorg_eolang_float_times", evaluateFloatFloatFloatFunChain (*))- , ("Lorg_eolang_float_plus", evaluateFloatFloatFloatFunChain (+))- , ("Lorg_eolang_float_div", evaluateFloatFloatFloatFunChain (/))- , ("Lorg_eolang_float_gt", evaluateBinaryDataizationFunChain boolToBytes bytesToFloat wrapBytesInBytes extractRho (extractLabel "x") (>))- , ("Lorg_eolang_float_times", evaluateFloatFloatFloatFunChain (*))- , ("Lorg_eolang_float_plus", evaluateFloatFloatFloatFunChain (+))- , ("Lorg_eolang_float_div", evaluateFloatFloatFloatFunChain (/))- , -- string- ("Lorg_eolang_string_length", evaluateUnaryDataizationFunChain intToBytes bytesToString wrapBytesInInt extractRho length)- ,- ( "Lorg_eolang_string_slice"- , \name obj state -> do- thisStr <- incLogLevel $ dataizeRecursivelyChain True (extractRho obj)- string <- case thisStr of- Right bytes -> pure $ bytesToString bytes- Left _ -> fail "Couldn't find bytes"- evaluateBinaryDataizationFunChain stringToBytes bytesToInt wrapBytesInString (extractLabel "start") (extractLabel "len") (\start len -> take len (drop start string)) name obj state- )- , -- others- ("Lorg_eolang_dataized", evaluateUnaryDataizationFunChain id id wrapBytesInBytes (extractLabel "target") id)- , ("Lorg_eolang_error", evaluateUnaryDataizationFunChain stringToBytes bytesToString wrapBytesInBytes (extractLabel "message") error)- ,- ( "Package"- , let- f _name obj@(Formation bindings) = do- \state -> do- fmap dataizePackage getContext >>= \case- True -> do- let (packageBindings, restBindings) = span isPackage bindings- bs <- mapM dataizeBindingChain restBindings- logStep "Dataized 'Package' siblings" (Left $ Formation (bs ++ packageBindings))- return (Formation (bs ++ packageBindings), state)- False ->- return (Formation bindings, state)- where- isPackage (LambdaBinding (Function "Package")) = True- isPackage _ = False- dataizeBindingChain (AlphaBinding attr o) = do- ctx <- getContext- let extendedContext = (extendContextWith obj ctx){currentAttr = attr}- dataizationResult <- incLogLevel $ withContext extendedContext $ dataizeRecursivelyChain False o- return (AlphaBinding attr (either id (Formation . singleton . DeltaBinding) dataizationResult))- dataizeBindingChain b = return b- f name _otherwise = evaluateBuiltinFunChainUnknown name _otherwise- in- f- )- ]---- | Atoms supported by 'evaluateBuiltinFunChain'-knownAtomNames :: HashSet String-knownAtomNames = fromList $ fst <$> knownAtoms--defaultContext :: [NamedRule] -> Object -> Context-defaultContext rules obj =- Context- { builtinRules = False- , allRules = rules- , enabledAtomNames = knownAtomNames- , outerFormations = NonEmpty.singleton obj- , currentAttr = Phi- , insideFormation = False- , insideAbstractFormation = False- , dataizePackage = True- , minimizeTerms = False- , insideSubObject = False- }--mkEnabledAtomNames :: [String] -> [String] -> HashSet String-mkEnabledAtomNames enabled disabled = enabledSet'- where- enabledSet =- case enabled of- [] -> knownAtomNames- _ -> fromList enabled- disabledSet = fromList disabled- enabledSet' = difference enabledSet disabledSet--knownAtomsSet :: HashMap.HashMap String (String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState))-knownAtomsSet = HashMap.fromList knownAtoms- -- | Like `evaluateDataizationFunChain` but specifically for the built-in functions. -- This function is not safe. It returns undefined for unknown functions evaluateBuiltinFunChain :: String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState)-evaluateBuiltinFunChain name obj =- case HashMap.lookup name knownAtomsSet of- Just f -> f name obj- Nothing -> evaluateBuiltinFunChainUnknown name obj+evaluateBuiltinFunChain name obj state = do+ ctx <- getContext+ case HashMap.lookup name ctx.knownAtoms of+ Just f -> f name obj state+ Nothing -> evaluateBuiltinFunChainUnknown name obj state -evaluateBuiltinFunChainUnknown :: String -> a -> b1 -> Chain (Either a b2) (a, b1)+evaluateBuiltinFunChainUnknown :: String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState) evaluateBuiltinFunChainUnknown atomName obj state = do logStep [fmt|[INFO]: unknown atom ({atomName})|] (Left obj) return (obj, state)@@ -409,3 +262,31 @@ -- This function is not safe. It returns undefined for unknown functions evaluateBuiltinFun :: Context -> String -> Object -> EvaluationState -> (Object, EvaluationState) evaluateBuiltinFun ctx name obj state = snd $ head $ runChain (evaluateBuiltinFunChain name obj state) ctx -- FIXME: head is bad++evaluateIODataizationFunChain :: IO String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState)+evaluateIODataizationFunChain action _obj state =+ return (Formation [DeltaBinding (stringToBytes (unsafePerformIO action))], state)++extractRho :: Object -> Object+extractRho = (`ObjectDispatch` Rho)+extractAlpha0 :: Object -> Object+extractAlpha0 = (`ObjectDispatch` Alpha (AlphaIndex "α0"))+extractLabel :: String -> Object -> Object+extractLabel attrName = (`ObjectDispatch` Label (LabelId attrName))+wrapBytesInInt :: Bytes -> Object+wrapBytesInInt (Bytes bytes) = [fmt|Φ.org.eolang.int(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes}))|]+wrapBytesInFloat :: Bytes -> Object+wrapBytesInFloat (Bytes bytes) = [fmt|Φ.org.eolang.float(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes}))|]+wrapBytesInString :: Bytes -> Object+wrapBytesInString (Bytes bytes) = [fmt|Φ.org.eolang.string(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes}))|]+wrapBytesInBytes :: Bytes -> Object+wrapBytesInBytes (Bytes bytes) = [fmt|Φ.org.eolang.bytes(Δ ⤍ {bytes})|]+wrapTermination :: Object+wrapTermination = [fmt|Φ.org.eolang.error(α0 ↦ Φ.org.eolang.string(as-bytes ↦ Φ.org.eolang.bytes(Δ ⤍ {bytes})))|]+ where+ Bytes bytes = stringToBytes "unknown error"++wrapBytesAsBool :: Bytes -> Object+wrapBytesAsBool bytes+ | bytesToInt bytes == 0 = [fmt|Φ.org.eolang.false|]+ | otherwise = [fmt|Φ.org.eolang.true|]
+ src/Language/EO/Phi/Dataize/Atoms.hs view
@@ -0,0 +1,94 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-}++module Language.EO.Phi.Dataize.Atoms where++import Data.Bits+import Data.List (singleton)+import Language.EO.Phi.Dataize+import Language.EO.Phi.Rules.Common+import Language.EO.Phi.Syntax.Abs++knownAtomsList :: [(String, String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState))]+knownAtomsList =+ [ ("Lorg_eolang_int_gt", evaluateIntIntBoolFunChain (>))+ , ("Lorg_eolang_int_plus", evaluateIntIntIntFunChain (+))+ , ("Lorg_eolang_int_times", evaluateIntIntIntFunChain (*))+ , ("Lorg_eolang_int_div", evaluateIntIntIntFunChain quot)+ , ("Lorg_eolang_bytes_eq", evaluateBinaryDataizationFunChain boolToBytes bytesToInt wrapBytesAsBool extractRho (extractLabel "b") (==))+ ,+ ( "Lorg_eolang_bytes_size"+ , let f = evaluateUnaryDataizationFunChain intToBytes id wrapBytesInBytes extractRho (\(Bytes bytes) -> length (words (map dashToSpace bytes)))+ where+ dashToSpace '-' = ' '+ dashToSpace c = c+ in f+ )+ ,+ ( "Lorg_eolang_bytes_slice"+ , \name obj state -> do+ thisStr <- incLogLevel $ dataizeRecursivelyChain True (extractRho obj)+ bytes <- case thisStr of+ Right bytes -> pure bytes+ Left _ -> fail "Couldn't find bytes"+ evaluateBinaryDataizationFunChain id bytesToInt wrapBytesInBytes (extractLabel "start") (extractLabel "len") (sliceBytes bytes) name obj state+ )+ , ("Lorg_eolang_bytes_and", evaluateBytesBytesBytesFunChain (.&.))+ , ("Lorg_eolang_bytes_or", evaluateBytesBytesBytesFunChain (.|.))+ , ("Lorg_eolang_bytes_xor", evaluateBytesBytesBytesFunChain (.^.))+ , ("Lorg_eolang_bytes_not", evaluateBytesBytesFunChain complement)+ , ("Lorg_eolang_bytes_right", evaluateBinaryDataizationFunChain intToBytes bytesToInt wrapBytesInBytes extractRho (extractLabel "x") (\x i -> shift x (-i)))+ , ("Lorg_eolang_bytes_concat", evaluateBinaryDataizationFunChain id id wrapBytesInBytes extractRho (extractLabel "b") concatBytes)+ , -- float+ ("Lorg_eolang_float_gt", evaluateBinaryDataizationFunChain boolToBytes bytesToFloat wrapBytesInBytes extractRho (extractLabel "x") (>))+ , ("Lorg_eolang_float_times", evaluateFloatFloatFloatFunChain (*))+ , ("Lorg_eolang_float_plus", evaluateFloatFloatFloatFunChain (+))+ , ("Lorg_eolang_float_div", evaluateFloatFloatFloatFunChain (/))+ , ("Lorg_eolang_float_gt", evaluateBinaryDataizationFunChain boolToBytes bytesToFloat wrapBytesInBytes extractRho (extractLabel "x") (>))+ , ("Lorg_eolang_float_times", evaluateFloatFloatFloatFunChain (*))+ , ("Lorg_eolang_float_plus", evaluateFloatFloatFloatFunChain (+))+ , ("Lorg_eolang_float_div", evaluateFloatFloatFloatFunChain (/))+ , -- string+ ("Lorg_eolang_string_length", evaluateUnaryDataizationFunChain intToBytes bytesToString wrapBytesInInt extractRho length)+ ,+ ( "Lorg_eolang_string_slice"+ , \name obj state -> do+ thisStr <- incLogLevel $ dataizeRecursivelyChain True (extractRho obj)+ string <- case thisStr of+ Right bytes -> pure $ bytesToString bytes+ Left _ -> fail "Couldn't find bytes"+ evaluateBinaryDataizationFunChain stringToBytes bytesToInt wrapBytesInString (extractLabel "start") (extractLabel "len") (\start len -> take len (drop start string)) name obj state+ )+ , -- others+ ("Lorg_eolang_dataized", evaluateUnaryDataizationFunChain id id wrapBytesInBytes (extractLabel "target") id)+ , ("Lorg_eolang_error", evaluateUnaryDataizationFunChain stringToBytes bytesToString wrapBytesInBytes (extractLabel "message") error)+ ,+ ( "Package"+ , let+ f _name obj@(Formation bindings) = do+ \state ->+ getContext+ >>= ( \case+ True -> do+ let (packageBindings, restBindings) = span isPackage bindings+ bs <- mapM dataizeBindingChain restBindings+ logStep "Dataized 'Package' siblings" (Left $ Formation (bs ++ packageBindings))+ return (Formation (bs ++ packageBindings), state)+ False ->+ return (Formation bindings, state)+ )+ . dataizePackage+ where+ isPackage (LambdaBinding (Function "Package")) = True+ isPackage _ = False+ dataizeBindingChain (AlphaBinding attr o) = do+ ctx <- getContext+ let extendedContext = (extendContextWith obj ctx){currentAttr = attr}+ dataizationResult <- incLogLevel $ withContext extendedContext $ dataizeRecursivelyChain False o+ return (AlphaBinding attr (either id (Formation . singleton . DeltaBinding) dataizationResult))+ dataizeBindingChain b = return b+ f name _otherwise = evaluateBuiltinFunChainUnknown name _otherwise+ in+ f+ )+ ]
+ src/Language/EO/Phi/Dataize/Context.hs view
@@ -0,0 +1,39 @@+module Language.EO.Phi.Dataize.Context where++import Data.HashMap.Strict qualified as HashMap+import Data.HashSet as HashSet (difference, fromList, intersection, member)+import Data.List.NonEmpty qualified as NonEmpty+import Language.EO.Phi.Dataize.Atoms as Atoms+import Language.EO.Phi.Rules.Common+import Language.EO.Phi.Syntax.Abs++knownAtomsMap :: Atoms+knownAtomsMap = HashMap.fromList knownAtomsList++defaultContext :: [NamedRule] -> Object -> Context+defaultContext rules obj =+ Context+ { builtinRules = False+ , allRules = rules+ , enabledAtoms = mkEnabledAtoms [] []+ , knownAtoms = knownAtomsMap+ , outerFormations = NonEmpty.singleton obj+ , currentAttr = Phi+ , insideFormation = False+ , insideAbstractFormation = False+ , dataizePackage = True+ , minimizeTerms = False+ , insideSubObject = False+ }++mkEnabledAtoms :: [String] -> [String] -> Atoms+mkEnabledAtoms enabled disabled = enabledAtoms'+ where+ knownAtomsSet = HashSet.fromList (HashMap.keys knownAtomsMap)+ disabledSet = HashSet.fromList disabled+ enabledSet =+ case enabled of+ [] -> knownAtomsSet+ _ -> HashSet.fromList enabled+ enabled' = HashSet.intersection (HashSet.difference enabledSet disabledSet) knownAtomsSet+ enabledAtoms' = HashMap.filterWithKey (\k _ -> k `HashSet.member` enabled') knownAtomsMap
src/Language/EO/Phi/Report/Html.hs view
@@ -18,6 +18,7 @@ module Language.EO.Phi.Report.Html where import Data.FileEmbed (embedFileRelative)+import Data.Functor ((<&>)) import Data.List (intercalate) import Data.Maybe (catMaybes, fromMaybe) import Data.Text qualified as T@@ -89,31 +90,57 @@ toMarkup :: Percent -> Markup toMarkup = toMarkup . show --- >>> pipelineConfig = ReportConfig { general = ReportGeneralConfig { expectedMetricsChange = 0, format = ReportFormat'Markdown } }+class (Num a) => ToDataSort a where+ toDataSort :: a -> Integer++-- TODO #389:30m+-- I couldn't make PyF pad doubles with zeros using {n:05} syntax+-- because PyF also counts the digits after .+instance ToDataSort Double where+ toDataSort :: Double -> Integer+ toDataSort number = round $ number * 1000++instance ToDataSort Percent where+ toDataSort :: Percent -> Integer+ toDataSort (Percent number) = toDataSort number++instance ToDataSort Integer where+ toDataSort :: Integer -> Integer+ toDataSort x = x++mkDataSortAttribute :: AttributeValue -> Attribute+mkDataSortAttribute = dataAttribute "sort"++-- >>> pipelineConfig = ReportFormat'Markdown ----- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'Bad 0.2)--- "<td class=\"number bad\">0.2\128308</td>"+-- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'Bad (Percent 0.2))+-- "<td class=\"number bad\" data-sort=\"1000200\">20.00%\128308</td>" ----- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'Good 0.5)--- "<td class=\"number good\">0.5\128994</td>"--- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'NA :: MetricsChangeCategory Double)--- "<td class=\"number not-applicable\">N/A\128995</td>"-toHtmlChange :: (ToMarkup a) => ReportFormat -> MetricsChangeCategory a -> Html+-- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'Good (Percent 0.5))+-- "<td class=\"number good\" data-sort=\"1000500\">50.00%\128994</td>"+-- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'NA :: MetricsChangeCategory Percent)+-- "<td class=\"number not-applicable\" data-sort=\"0000000\">N/A\128995</td>"+toHtmlChange :: forall a. (ToMarkup a, ToDataSort a) => ReportFormat -> MetricsChangeCategory a -> Html toHtmlChange reportFormat = \case- MetricsChange'NA -> td ! class_ "number not-applicable" $ toHtml ("N/A" :: String) <> toHtml ['🟣' | isMarkdown]- MetricsChange'Bad{..} -> td ! class_ "number bad" $ toHtml change <> toHtml ['🔴' | isMarkdown]- MetricsChange'Good{..} -> td ! class_ "number good" $ toHtml change <> toHtml ['🟢' | isMarkdown]+ MetricsChange'NA -> td ! class_ [fmt|{number} not-applicable|] ! mkDataSortAttributeNA $ toHtml na <> toHtml ['🟣' | isMarkdown]+ MetricsChange'Bad{..} -> td ! class_ [fmt|{number} bad|] ! mkDataSortAttributeChange change $ toHtml change <> toHtml ['🔴' | isMarkdown]+ MetricsChange'Good{..} -> td ! class_ [fmt|{number} good|] ! mkDataSortAttributeChange change $ toHtml change <> toHtml ['🟢' | isMarkdown] where isMarkdown = reportFormat == ReportFormat'Markdown+ mkDataSortAttributeChange change = mkDataSortAttribute [fmt|1{toDataSort change:06}|]+ mkDataSortAttributeNA = mkDataSortAttribute [fmt|0{(toDataSort (Percent 0.0)):06}|]+ na :: String+ na = "N/A"+ number :: String+ number = "number" toHtmlMetricsChange :: ReportFormat -> MetricsChangeCategorized -> [Html] toHtmlMetricsChange reportFormat change = toHtmlChange reportFormat <$> toListMetrics change toHtmlMetrics :: MetricsCount -> [Html] toHtmlMetrics metrics =- (td ! class_ "number")- . toHtml- <$> toListMetrics metrics+ toListMetrics metrics+ <&> (\x -> td ! class_ "number" ! mkDataSortAttribute [fmt|{x:06}|] $ toHtml x) toHtmlReportRow :: ReportFormat -> Int -> ReportRow -> Html toHtmlReportRow reportFormat index reportRow =@@ -121,8 +148,8 @@ ( td . toHtml <$> [ [fmt|{index}|]- , fromMaybe "[N/A]" reportRow.attributeInitial- , fromMaybe "[N/A]" reportRow.attributeNormalized+ , fromMaybe na reportRow.attributeInitial+ , fromMaybe na reportRow.attributeNormalized ] ) <> toHtmlMetricsChange reportFormat reportRow.metricsChange@@ -130,12 +157,16 @@ <> toHtmlMetrics reportRow.metricsNormalized <> ( td . toHtml- <$> [ fromMaybe "[all programs]" reportRow.fileInitial- , intercalate "." $ fromMaybe ["[whole program]"] reportRow.bindingsPathInitial- , fromMaybe "[all programs]" reportRow.fileNormalized- , intercalate "." $ fromMaybe ["[whole program]"] reportRow.bindingsPathNormalized+ <$> [ fromMaybe allPrograms reportRow.fileInitial+ , intercalate "." $ fromMaybe [wholeProgram] reportRow.bindingsPathInitial+ , fromMaybe allPrograms reportRow.fileNormalized+ , intercalate "." $ fromMaybe [wholeProgram] reportRow.bindingsPathNormalized ] )+ where+ wholeProgram = "[whole program]"+ allPrograms = "[all programs]"+ na = "[N/A]" toHtmlReport :: ReportFormat -> PipelineConfig -> Report -> Html toHtmlReport reportFormat pipelineConfig report =
src/Language/EO/Phi/Rules/Common.hs view
@@ -17,7 +17,7 @@ import Data.ByteString (ByteString) import Data.ByteString qualified as ByteString.Strict import Data.Char (toUpper)-import Data.HashSet (HashSet)+import Data.HashMap.Strict qualified as HashMap import Data.List (intercalate, minimumBy, nubBy, sortOn) import Data.List.NonEmpty (NonEmpty (..), (<|)) import Data.Ord (comparing)@@ -58,12 +58,17 @@ Left parseError -> error (parseError <> "\non input\n" <> input <> "\n") Right object -> object +-- | State of evaluation is not needed yet, but it might be in the future+type EvaluationState = ()+ type NamedRule = (String, Rule)+type Atoms = HashMap.HashMap String (String -> Object -> EvaluationState -> DataizeChain (Object, EvaluationState)) data Context = Context { builtinRules :: Bool , allRules :: [NamedRule]- , enabledAtomNames :: HashSet String+ , enabledAtoms :: Atoms+ , knownAtoms :: Atoms , outerFormations :: NonEmpty Object , currentAttr :: Attribute , insideFormation :: Bool@@ -250,9 +255,6 @@ equalBinding :: Binding -> Binding -> Bool equalBinding (AlphaBinding attr1 obj1) (AlphaBinding attr2 obj2) = attr1 == attr2 && equalObject obj1 obj2--- Ignore deltas for now while comparing since different normalization paths can lead to different vertex data--- TODO #120:30m normalize the deltas instead of ignoring since this actually suppresses problems-equalBinding (DeltaBinding _) (DeltaBinding _) = True equalBinding b1 b2 = b1 == b2 -- * Chain variants
src/Language/EO/Phi/Rules/RunYegor.hs view
@@ -1,6 +1,6 @@ module Language.EO.Phi.Rules.RunYegor where -import Language.EO.Phi.Dataize+import Language.EO.Phi.Dataize.Context import Language.EO.Phi.Rules.Common import Language.EO.Phi.Rules.Yaml qualified as Yaml import Language.EO.Phi.Syntax (printTree)
src/Language/EO/Phi/Rules/Yaml.hs view
@@ -93,8 +93,15 @@ { name :: String , input :: Object , output :: [Object]+ , options :: Maybe [RuleTestOption] } deriving (Generic, FromJSON, Show)++newtype RuleTestOption = TakeOne {take_one :: Bool}+ -- deriving (Generic, Show, FromJSON)+ deriving (Eq, Generic, Show)+instance FromJSON RuleTestOption where+ parseJSON = genericParseJSON defaultOptions{sumEncoding = UntaggedValue} data AttrsInBindings = AttrsInBindings { attrs :: [RuleAttribute]
src/Language/EO/Phi/ToLaTeX.hs view
@@ -1,6 +1,8 @@ {-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RecordWildCards #-} module Language.EO.Phi.ToLaTeX where @@ -9,6 +11,7 @@ import Data.String (IsString) import Data.Text qualified as T import Language.EO.Phi+import Language.EO.Phi.Rules.Yaml import Text.Regex (mkRegex, subRegex) newtype LaTeX = LaTeX {unLaTeX :: String}@@ -31,7 +34,7 @@ toLatex Rho = "^" toLatex (Alpha (AlphaIndex a)) = LaTeX ("\\alpha_" ++ tail a) toLatex (Label (LabelId l)) = LaTeX l- toLatex (MetaAttr _) = error "rendering MetaBindings in LaTex format"+ toLatex (MetaAttr (LabelMetaId l)) = LaTeX l instance ToLatex Binding where toLatex (AlphaBinding attr obj) = toLatex attr <> " -> " <> toLatex obj@@ -39,8 +42,8 @@ toLatex (DeltaBinding (Bytes bytes)) = "D> " <> LaTeX bytes toLatex DeltaEmptyBinding = "D> ?" toLatex (LambdaBinding (Function fn)) = "L> " <> LaTeX fn- toLatex (MetaBindings _) = error "rendering MetaBindings in LaTex format"- toLatex (MetaDeltaBinding _) = error "rendering MetaDeltaBinding in LaTex format"+ toLatex (MetaBindings (BindingsMetaId x)) = LaTeX x+ toLatex (MetaDeltaBinding (BytesMetaId x)) = "D> " <> LaTeX x instance ToLatex Object where toLatex (Formation bindings) =@@ -50,20 +53,99 @@ toLatex (ObjectDispatch obj attr) = toLatex obj <> "." <> toLatex attr toLatex GlobalObject = "Q"- toLatex ThisObject = "$"+ toLatex ThisObject = "\\xi" toLatex Termination = "\\dead"- toLatex (MetaObject _) = error "rendering MetaObject in LaTex format"+ toLatex (MetaObject (ObjectMetaId metaId)) = LaTeX metaId toLatex MetaTailContext{} = error "rendering MetaTailContext in LaTex format" toLatex (MetaFunction _ _) = error "rendering MetaFunction in LaTex format"- toLatex (MetaSubstThis _ _) = error "rendering MetaSubstThis in LaTex format"+ toLatex (MetaSubstThis obj1 obj2) = LaTeX "\\mathbb{S}(" <> toLatex obj1 <> ", " <> toLatex obj2 <> ")" removeOrgEolang :: String -> String removeOrgEolang = T.unpack . T.replace "Q.org.eolang" "QQ" . T.pack +substituteTau :: String -> String+substituteTau = T.unpack . T.replace "τ" "\\tau" . T.pack++removeExclamationsMarks :: String -> String+removeExclamationsMarks = filter (/= '!')+ removeAlpha :: String -> String removeAlpha s = subRegex (mkRegex "\\\\alpha_([0-9]+) ->") s "\\1->" -- >>> toLatex ("{ ⟦ α0 ↦ ξ, α1 ↦ Φ.org.eolang.bytes( Δ ⤍ 00- ) ⟧ }" :: Program) -- \Big\{ [[ 0-> $, 1-> QQ.bytes( D> 00- ) ]] \Big\} latexToString :: LaTeX -> String-latexToString = removeAlpha . removeOrgEolang . unLaTeX+latexToString = removeExclamationsMarks . substituteTau . removeAlpha . removeOrgEolang . unLaTeX++inMathMode :: LaTeX -> LaTeX+inMathMode = (" $ " <>) . (<> " $ ")++-- it's ok without separators here because rules have zero or one constraint from the context+instance ToLatex RuleContext where+ toLatex RuleContext{..} =+ maybe mempty (\x -> inMathMode $ toLatex GlobalObject <> " -> " <> toLatex x) global_object+ <> maybe mempty (\x -> (inMathMode $ toLatex x) <> " is the scope of the redex") current_object+ <> maybe mempty (\x -> toLatex x <> " is the current attribute") current_attribute++instance ToLatex RuleAttribute where+ toLatex (ObjectAttr a) = toLatex a+ toLatex DeltaAttr = "\\Delta"+ toLatex LambdaAttr = "\\lambda"++instance ToLatex Condition where+ toLatex (IsNF nf) = inMathMode $ toLatex nf <> "\\in\\mathcal{N}"+ toLatex (IsNFInsideFormation nf_inside_formation) =+ (inMathMode $ toLatex nf_inside_formation) <> " is nf inside formation"+ toLatex (PresentAttrs (AttrsInBindings attrs bindings)) =+ inMathMode $ fold (intersperse ", " (map toLatex attrs)) <> " \\in " <> foldMap toLatex bindings+ toLatex (AbsentAttrs (AttrsInBindings attrs bindings)) =+ inMathMode $ fold (intersperse ", " (map toLatex attrs)) <> " \\notin " <> foldMap toLatex bindings+ toLatex (AttrNotEqual (attr1, attr2)) =+ inMathMode $ toLatex attr1 <> " \\neq " <> toLatex attr2+ toLatex (ApplyInSubformations apply_in_subformations) =+ if not apply_in_subformations then LaTeX "not in subformations" else mempty+ toLatex (ApplyInAbstractSubformations apply_in_abstract_subformations) =+ if not apply_in_abstract_subformations then LaTeX "not in subformations" else mempty++isNonEmptyContext :: Maybe RuleContext -> Bool+isNonEmptyContext Nothing = False+isNonEmptyContext (Just (RuleContext Nothing Nothing Nothing)) = False+isNonEmptyContext _ = True++-- Renders all conditions on separate lines+instance ToLatex Rule where+ toLatex (Rule name _ context _ pattern result _ when _) =+ "\\rrule{"+ <> LaTeX name+ <> "}: &"+ <> inMathMode (toLatex pattern)+ <> "\\(\\trans\\)"+ <> inMathMode (toLatex result)+ <> (if not (null when) || isNonEmptyContext context then "\\\\\\text {if }" else mempty)+ <> maybe mempty (\c -> "&" <> toLatex c <> "\\\\") context+ <> fold (intersperse ",\\\\" (map (("&" <>) . toLatex) when))++instance ToLatex [Rule] where+ toLatex rules =+ "\\begin{figure*}\n\\begin{tabular}{rl}\n "+ <> fold (intersperse "\\\\\\\\\n " (map toLatex rules))+ <> "\n\\end{tabular}\n\\end{figure*}"++-- Renders all conditions in one line+ruleToLatexCompact :: Rule -> LaTeX+ruleToLatexCompact (Rule name _ context _ pattern result _ when _) =+ "\\rrule{"+ <> LaTeX name+ <> "}: "+ <> inMathMode (toLatex pattern)+ <> "\\(\\trans\\)"+ <> inMathMode (toLatex result)+ <> (if not (null when) || isNonEmptyContext context then "\\quad\\text {if }" else "")+ <> maybe mempty (\c -> toLatex c <> ", ") context+ <> fold (intersperse ", " (map toLatex when))++rulesToLatexCompact :: [Rule] -> LaTeX+rulesToLatexCompact rules =+ "\\begin{figure*}\n "+ <> fold (intersperse "\\\\\\vspace*{0.5em}\n " (map ruleToLatexCompact rules))+ <> "\n\\end{figure*}"
test/Language/EO/Phi/DataizeSpec.hs view
@@ -9,7 +9,8 @@ import Language.EO.Phi (printTree) import Language.EO.Phi qualified as Phi-import Language.EO.Phi.Dataize (dataizeRecursively, defaultContext)+import Language.EO.Phi.Dataize (dataizeRecursively)+import Language.EO.Phi.Dataize.Context (defaultContext) import Language.EO.Phi.Dependencies (deepMergePrograms) import Language.EO.Phi.Rules.Common (equalObject) import Language.EO.Phi.Rules.Yaml (convertRuleNamed, parseRuleSetFromFile, rules)
test/Language/EO/PhiSpec.hs view
@@ -15,7 +15,7 @@ import Data.String (IsString (..)) import Data.Yaml (decodeFileThrow) import Language.EO.Phi-import Language.EO.Phi.Dataize (defaultContext)+import Language.EO.Phi.Dataize.Context (defaultContext) import Language.EO.Phi.Metrics.Collect (getProgramMetrics) import Language.EO.Phi.Metrics.Data (BindingsByPathMetrics (..), ProgramMetrics (..)) import Language.EO.Phi.Rules.Common (Rule, equalProgram)
test/Language/EO/Rules/PhiPaperSpec.hs view
@@ -22,7 +22,7 @@ import Data.List qualified as List import Data.Yaml qualified as Yaml import GHC.Generics (Generic)-import Language.EO.Phi.Dataize (defaultContext)+import Language.EO.Phi.Dataize.Context (defaultContext) import Language.EO.Phi.Rules.Common (ApplicationLimits (..), NamedRule, applyOneRule, defaultApplicationLimits, equalObject, intToBytes, objectSize) import Language.EO.Phi.Rules.Yaml (convertRuleNamed, parseRuleSetFromFile, rules) import Language.EO.Phi.Syntax (printTree)
test/Language/EO/YamlSpec.hs view
@@ -4,9 +4,9 @@ module Language.EO.YamlSpec where import Control.Monad (forM_)-import Language.EO.Phi.Dataize (defaultContext)+import Language.EO.Phi.Dataize.Context (defaultContext) import Language.EO.Phi.Rules.Common (applyOneRule)-import Language.EO.Phi.Rules.Yaml (Rule (..), RuleSet (..), RuleTest (..), convertRuleNamed)+import Language.EO.Phi.Rules.Yaml (Rule (..), RuleSet (..), RuleTest (..), RuleTestOption (..), convertRuleNamed) import Test.EO.Yaml import Test.Hspec @@ -21,8 +21,9 @@ it ruleTest.name $ let rule' = convertRuleNamed rule resultOneStep = applyOneRule (defaultContext [rule'] ruleTest.input) ruleTest.input+ normalizationResult = maybe resultOneStep (\lst -> if TakeOne True `elem` lst then take 1 resultOneStep else resultOneStep) ruleTest.options expected = ruleTest.output- in map snd resultOneStep `shouldBe` expected+ in map snd normalizationResult `shouldBe` expected where testPaths = [ "test/eo/phi/rules/yegor.yaml"