overlay.language 0.2.0.post2.dev0__tar.gz → 0.2.0.post4.dev0__tar.gz

{overlay_language-0.2.0.post2.dev0 → overlay_language-0.2.0.post4.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overlay.language
-Version: 0.2.0.post2.dev0
+Version: 0.2.0.post4.dev0
 Summary: A dependency injection framework with pytest-fixture syntax, plus a configuration language for declarative programming
 Project-URL: Repository, https://github.com/Atry/overlay
 Author-email: "Yang, Bo" <yang-bo@yang-bo.com>

{overlay_language-0.2.0.post2.dev0 → overlay_language-0.2.0.post4.dev0}/docs/conf.py

@@ -51,6 +51,7 @@ html_theme_options = {
     'fixed_sidebar': True,
     'github_user': 'Atry',
     'github_repo': 'overlay',
+    'github_banner': True,
     'github_button': True,
     'github_type': 'watch',
     'github_count': True,

overlay_language-0.2.0.post4.dev0/docs/index.rst

@@ -0,0 +1,60 @@
+Overlay Language
+================
+
+``overlay.language`` is a dependency injection framework with pytest-fixture
+syntax, plus a configuration language for declarative programming. The package
+has two parts:
+
+The **Python decorator API** (``@scope``, ``@extern``, ``@resource``) gives you
+dependency injection with pytest-fixture syntax — declare what a function needs
+and the framework wires it up. Each module owns only its own concern; cross-
+cutting behaviour layers on via ``@patch`` without touching the original code.
+App-scoped singletons and per-request resources coexist naturally.
+See :doc:`tutorial`.
+
+The **Overlay language** is a configuration language written in ``.oyaml`` /
+``.ojson`` / ``.otoml`` files. SQL queries, format strings, URL patterns — all
+the business decisions that clutter Python code — live in the Overlay language
+instead, where independent modules deep-merge by name without glue code —
+dissolving the
+`Expression Problem <https://en.wikipedia.org/wiki/Expression_problem>`_.
+
+If you have ever struggled to mock a service that tangles I/O with business
+logic, or dreaded porting an application from sync to async, or needed to swap
+between providers without rewriting half your Python — the Overlay language can
+help. It is also a statically typed modern programming language based on
+`Overlay-Calculus <https://arxiv.org/abs/2602.16291>`_, which is provably more
+expressive than λ-calculus, so it can express your entire business logic — not
+just configuration. Move that logic into the Overlay language and Python reduces
+to thin I/O adapters that are trivial to mock or replace. The same Overlay code runs against any set of adapters and the business logic
+never changes, even when you
+port your synchronous program to async — the problem known as
+`function colour <https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/>`_.
+See :doc:`overlay-language-tutorial`.
+
+:doc:`installation`
+   Install the package from PyPI.
+
+:doc:`tutorial`
+   Getting started with the Python decorator API — build a web application
+   step by step using ``@scope``, ``@extern``, and ``@resource``.
+
+:doc:`overlay-language-tutorial`
+   Getting started with the Overlay language — rewrite the same application
+   in ``.oyaml``, separating business logic from I/O, then switch the
+   underlying framework to asyncio without changing your code.
+
+:doc:`specification`
+   Full language specification for the Overlay language.
+
+`API Reference <api/overlay.language.html>`__
+   Python API reference (auto-generated).
+
+.. toctree::
+   :hidden:
+
+   installation
+   tutorial
+   overlay-language-tutorial
+   specification
+   API Reference <api/overlay.language>

{overlay_language-0.2.0.post2.dev0 → overlay_language-0.2.0.post4.dev0}/docs/overlay-language-tutorial.rst

@@ -21,11 +21,12 @@ The Overlay language solves this by separating the application into three layers
   per operation (``sqlite3.connect``, ``str.split``, ``wfile.write``). Each adapter
   declares its inputs as ``@extern`` and exposes a single ``@public @resource``
   output. The adapter contains **zero business logic**.
-- **``.oyaml`` files** contain all application logic. Overlay is not just a
-  configuration format — it is a complete language with lexical scoping, nested
-  scopes, deep-merge composition, and lazy evaluation. These features make it
-  more natural than Python for expressing business logic, which is inherently
-  declarative ("the user ID is the last URL segment", "the response format is
+- **``.oyaml`` files** contain all application logic, written in the Overlay
+  language. The Overlay language is not just a configuration format — it is a
+  complete language with lexical scoping, nested scopes, deep-merge composition,
+  and lazy evaluation. These features make it more natural than Python for
+  expressing business logic, which is inherently declarative ("the user ID is
+  the last URL segment", "the response format is
   ``total={total} current={current}``").
 - **Configuration values** (SQL queries, format strings, host/port) are pure
   YAML scalars, gathered in one place.
@@ -282,7 +283,7 @@ Python vs Overlay language
 
    * - Aspect
      - Python ``@scope``
-     - ``.oyaml``
+     - Overlay language (``.oyaml``)
    * - Composition
      - Manual ``@extend`` + ``RelativeReference``
      - Inheritance list: ``- [Parent]``

overlay_language-0.2.0.post2.dev0/docs/index.rst

@@ -1,26 +0,0 @@
-Overlay Language
-================
-
-A dependency injection framework with pytest-fixture syntax, plus a
-configuration language for declarative programming.
-
-The configuration language is designed for modularity — independent modules
-compose freely without glue code, dissolving the
-`Expression Problem <https://en.wikipedia.org/wiki/Expression_problem>`_.
-If you prefer declarative programming, you can even move all your business logic
-from Python into the Overlay language — it is based on
-`Overlay-Calculus <https://arxiv.org/abs/2602.16291>`_, which is provably more
-expressive than λ-calculus. As a bonus, your Python code
-reduces to thin I/O adapters, trivially mockable, and the same Overlay language
-code runs unchanged on both sync and async runtimes
-(a.k.a. `function-color <https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/>`_-blind).
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Contents:
-
-   installation
-   tutorial
-   overlay-language-tutorial
-   specification
-   API Reference <api/overlay.language>