diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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 diff --git a/app/Main.hs b/app/Main.hs --- a/app/Main.hs +++ b/app/Main.hs @@ -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 diff --git a/data/0.36.0/dependencies.md b/data/0.36.0/dependencies.md new file mode 100644 --- /dev/null +++ b/data/0.36.0/dependencies.md @@ -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 + ⟧ + ⟧ +} +``` + diff --git a/data/0.37.0/dependencies.md b/data/0.37.0/dependencies.md new file mode 100644 --- /dev/null +++ b/data/0.37.0/dependencies.md @@ -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 + ⟧ + ⟧ +} +``` + diff --git a/data/0.38.0/dependencies.md b/data/0.38.0/dependencies.md new file mode 100644 --- /dev/null +++ b/data/0.38.0/dependencies.md @@ -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 + ⟧ + ⟧ +} +``` + diff --git a/data/0.38.4/dependencies.md b/data/0.38.4/dependencies.md new file mode 100644 --- /dev/null +++ b/data/0.38.4/dependencies.md @@ -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 + ⟧ + ⟧ +} +``` + diff --git a/eo-phi-normalizer.cabal b/eo-phi-normalizer.cabal --- a/eo-phi-normalizer.cabal +++ b/eo-phi-normalizer.cabal @@ -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 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 diff --git a/src/Language/EO/Phi/Dataize.hs b/src/Language/EO/Phi/Dataize.hs --- a/src/Language/EO/Phi/Dataize.hs +++ b/src/Language/EO/Phi/Dataize.hs @@ -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|] diff --git a/src/Language/EO/Phi/Dataize/Atoms.hs b/src/Language/EO/Phi/Dataize/Atoms.hs new file mode 100644 --- /dev/null +++ b/src/Language/EO/Phi/Dataize/Atoms.hs @@ -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 + ) + ] diff --git a/src/Language/EO/Phi/Dataize/Context.hs b/src/Language/EO/Phi/Dataize/Context.hs new file mode 100644 --- /dev/null +++ b/src/Language/EO/Phi/Dataize/Context.hs @@ -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 diff --git a/src/Language/EO/Phi/Report/Html.hs b/src/Language/EO/Phi/Report/Html.hs --- a/src/Language/EO/Phi/Report/Html.hs +++ b/src/Language/EO/Phi/Report/Html.hs @@ -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) --- "0.2\128308" +-- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'Bad (Percent 0.2)) +-- "20.00%\128308" -- --- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'Good 0.5) --- "0.5\128994" --- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'NA :: MetricsChangeCategory Double) --- "N/A\128995" -toHtmlChange :: (ToMarkup a) => ReportFormat -> MetricsChangeCategory a -> Html +-- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'Good (Percent 0.5)) +-- "50.00%\128994" +-- >>> renderHtml $ toHtmlChange pipelineConfig (MetricsChange'NA :: MetricsChangeCategory Percent) +-- "N/A\128995" +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 = diff --git a/src/Language/EO/Phi/Rules/Common.hs b/src/Language/EO/Phi/Rules/Common.hs --- a/src/Language/EO/Phi/Rules/Common.hs +++ b/src/Language/EO/Phi/Rules/Common.hs @@ -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 diff --git a/src/Language/EO/Phi/Rules/RunYegor.hs b/src/Language/EO/Phi/Rules/RunYegor.hs --- a/src/Language/EO/Phi/Rules/RunYegor.hs +++ b/src/Language/EO/Phi/Rules/RunYegor.hs @@ -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) diff --git a/src/Language/EO/Phi/Rules/Yaml.hs b/src/Language/EO/Phi/Rules/Yaml.hs --- a/src/Language/EO/Phi/Rules/Yaml.hs +++ b/src/Language/EO/Phi/Rules/Yaml.hs @@ -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] diff --git a/src/Language/EO/Phi/ToLaTeX.hs b/src/Language/EO/Phi/ToLaTeX.hs --- a/src/Language/EO/Phi/ToLaTeX.hs +++ b/src/Language/EO/Phi/ToLaTeX.hs @@ -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*}" diff --git a/test/Language/EO/Phi/DataizeSpec.hs b/test/Language/EO/Phi/DataizeSpec.hs --- a/test/Language/EO/Phi/DataizeSpec.hs +++ b/test/Language/EO/Phi/DataizeSpec.hs @@ -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) diff --git a/test/Language/EO/PhiSpec.hs b/test/Language/EO/PhiSpec.hs --- a/test/Language/EO/PhiSpec.hs +++ b/test/Language/EO/PhiSpec.hs @@ -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) diff --git a/test/Language/EO/Rules/PhiPaperSpec.hs b/test/Language/EO/Rules/PhiPaperSpec.hs --- a/test/Language/EO/Rules/PhiPaperSpec.hs +++ b/test/Language/EO/Rules/PhiPaperSpec.hs @@ -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) diff --git a/test/Language/EO/YamlSpec.hs b/test/Language/EO/YamlSpec.hs --- a/test/Language/EO/YamlSpec.hs +++ b/test/Language/EO/YamlSpec.hs @@ -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"