synalog 2.1.0__tar.gz → 2.2.0__tar.gz

{synalog-2.1.0 → synalog-2.2.0}/Cargo.lock

@@ -2348,7 +2348,7 @@ dependencies = [
 
 [[package]]
 name = "synalog"
-version = "2.1.0"
+version = "2.2.0"
 dependencies = [
  "anyhow",
  "duckdb",

{synalog-2.1.0 → synalog-2.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "synalog"
-version = "2.1.0"
+version = "2.2.0"
 edition = "2024"
 description = "Logic programming for AI agents: Datalog-family language compiling to optimized SQL"
 license = "Apache-2.0"

{synalog-2.1.0 → synalog-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synalog
-Version: 2.1.0
+Version: 2.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3
@@ -289,18 +289,18 @@ A Synalog program is a **project**: a folder with a `layer.toml`, holding one pr
 
 ```
 shop/
-├── tables/Orders.l               # the data: one file per database table
-├── concepts/Customer.l           # entities and relationships extracted from tables
-├── rules/CustomerRevenue.l       # insights derived from concepts
-├── rules/TopCustomers.l
+├── tables/orders.l               # the data: one file per database table
+├── concepts/customer.l           # entities and relationships extracted from tables
+├── rules/customer_revenue.l       # insights derived from concepts
+├── rules/top_customers.l
 └── layer.toml                    # the project's name, description and database
 ```
 
 Each file is named after its predicate and opens with front matter (`name`, the predicate; `description`, what its rows are), then imports what it builds on by folder, file and predicate, then orders its predicate with `@OrderBy`. A database table is referenced by its lowercase database name in `tables/`, and everything else builds on the PascalCase predicate that maps it:
 
-`tables/Orders.l`
+`tables/orders.l`
 
-```logica
+```synalog
 ---
 name: Orders
 description: One row per order, with its customer, amount and status.
@@ -310,41 +310,41 @@ Orders(order_id:, customer_id:, amount:, status:) :-
   orders(order_id:, customer_id:, amount:, status:);
 ```
 
-`concepts/Customer.l`
+`concepts/customer.l`
 
-```logica
+```synalog
 ---
 name: Customer
 description: Every customer who placed at least one order.
 ---
-import tables.Orders.Orders;
+import tables.orders.Orders;
 
 @OrderBy(Customer, "customer_id");
 Customer(customer_id:) distinct :- Orders(customer_id:);
 ```
 
-`rules/CustomerRevenue.l`
+`rules/customer_revenue.l`
 
-```logica
+```synalog
 ---
 name: CustomerRevenue
 description: Total amount ordered by each customer, all statuses included.
 ---
-import concepts.Customer.Customer;
-import tables.Orders.Orders;
+import concepts.customer.Customer;
+import tables.orders.Orders;
 
 @OrderBy(CustomerRevenue, "customer_id");
 CustomerRevenue(customer_id:, total? += amount) distinct :-
   Customer(customer_id:), Orders(customer_id:, amount:);
 ```
 
-Imports resolve from the project's folder, so every file runs on its own: `synalog rules/CustomerRevenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
+Imports resolve from the project's folder, so every file runs on its own: `synalog rules/customer_revenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
 
 ### Named arguments
 
 Synalog uses **named arguments only** (no positional arguments). The left side of `:` is the column name, the right side is the variable:
 
-```logica
+```synalog
 # column "amount" bound to variable "total"
 Orders(amount: total)
 
@@ -356,7 +356,7 @@ Orders(amount:)
 
 Variables are defined with `==`. Arithmetic, string and comparison operators are supported:
 
-```logica
+```synalog
 OrderWithTax(order_id:, total:) :-
   Orders(order_id:, amount:),
   total == amount * 1.10;
@@ -368,7 +368,7 @@ OrderWithTax(order_id:, total:) :-
 
 Aggregation uses the `distinct` keyword and special operators in the rule head:
 
-```logica
+```synalog
 # Sum
 Revenue(total? += amount) distinct :- Orders(amount:);
 
@@ -392,7 +392,7 @@ TopSeller(name? ArgMax= name -> revenue) distinct :- Sales(name:, revenue:);
 
 ### Logical operators
 
-```logica
+```synalog
 # Conjunction (AND), comma
 Result(x:, y:) :- TableA(x:), TableB(x:, y:);
 
@@ -405,14 +405,14 @@ Inactive(user_id:) :- Users(user_id:), ~Logins(user_id:);
 
 Multiple rule definitions for the same predicate combine results (union):
 
-```logica
+```synalog
 HighValue(user_id:) :- Orders(user_id:, amount:), amount > 10000;
 HighValue(user_id:) :- Referrals(user_id:, tier: "vip");
 ```
 
 ### Conditionals
 
-```logica
+```synalog
 OrderSize(order_id:, size:) :-
   Orders(order_id:, amount:),
   size == (if amount > 1000 then "large"
@@ -424,7 +424,7 @@ OrderSize(order_id:, size:) :-
 
 Directives control predicate behavior and **must be placed before** the rule definition:
 
-```logica
+```synalog
 @OrderBy(TopCustomers, "total", "DESC");
 @Limit(TopCustomers, 10);
 TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, amount:);
@@ -442,7 +442,7 @@ TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, am
 
 Functors let you reuse predicate logic by parameterizing input predicates:
 
-```logica
+```synalog
 # Define a reusable pattern
 @OrderBy(SegmentRevenue, "segment_id");
 SegmentRevenue(segment_id:, total? += amount) distinct :-
@@ -458,7 +458,7 @@ SMBRevenue := SegmentRevenue(Segment: SMBCustomers);
 
 Recursive predicates compute transitive closures, for example finding all managers above an employee:
 
-```logica
+```synalog
 @Recursive(AllManagers, 20);
 
 # Base case: direct manager
@@ -476,7 +476,7 @@ Useful for: referral chains, org charts, product taxonomies, bill of materials.
 
 Find shortest paths in weighted graphs by enumerating route costs recursively, then keeping the minimum per destination with a `Min=` aggregation:
 
-```logica
+```synalog
 # Enumerate route costs from the origin, hop by hop.
 @Recursive(RouteCost, 10);
 RouteCost(destination:, cost:) :-
@@ -495,7 +495,7 @@ ShippingCost(destination:, total? Min= cost) distinct :- RouteCost(destination:,
 
 When working with timestamps or dates, always convert to string first:
 
-```logica
+```synalog
 @OrderBy(MonthlyOrders, "month");
 MonthlyOrders(month:, count? += 1) distinct :-
   Orders(created_at:),
@@ -509,7 +509,7 @@ RecentOrders(order_id:) :-
 
 `Today(date:)` (today's date as `"YYYY-MM-DD"`) and `Now(timestamp:)` (the current instant as the engine's native timestamp) are built-in concepts. They are inlined per dialect by the compiler, with no runtime table needed, so they work on every engine. `Now` is the most precise value; derive coarser parts (date, time, hour) from it through the `ToString` → `Substr` pipeline. Join against `Today` whenever a rule needs "today":
 
-```logica
+```synalog
 @OrderBy(ThisMonthOrders, "order_id");
 ThisMonthOrders(order_id:, created_at:) :-
   Orders(order_id:, created_at:),
@@ -523,7 +523,7 @@ They are reserved names: you cannot redefine, extend, or update them.
 
 Entities and relationships become node and edge concepts, and rules traverse them. Edges join **through** the node concepts rather than the raw table, so a filter on a node applies to every edge built on it:
 
-```logica
+```synalog
 @OrderBy(Person, "person_id");
 Person(person_id:, name:, profile_url:) distinct :- Employees(person_id:, name:, profile_url:);
 
@@ -536,7 +536,7 @@ WorksIn(person_id:, department_id:) distinct :-
 
 Relationships with a lifetime carry it as a half-open interval `[valid_from, valid_to)`, using `"9999-12-31"` as the open end so ISO strings compare correctly, and `Today` supplies the clock for point-in-time questions:
 
-```logica
+```synalog
 @OrderBy(CurrentEmployment, "person_id");
 CurrentEmployment(person_id:, company_id:, role:) distinct :-
   EmployedAt(person_id:, company_id:, role:, valid_from:, valid_to:),

{synalog-2.1.0 → synalog-2.2.0}/README.md

@@ -247,18 +247,18 @@ A Synalog program is a **project**: a folder with a `layer.toml`, holding one pr
 
 ```
 shop/
-├── tables/Orders.l               # the data: one file per database table
-├── concepts/Customer.l           # entities and relationships extracted from tables
-├── rules/CustomerRevenue.l       # insights derived from concepts
-├── rules/TopCustomers.l
+├── tables/orders.l               # the data: one file per database table
+├── concepts/customer.l           # entities and relationships extracted from tables
+├── rules/customer_revenue.l       # insights derived from concepts
+├── rules/top_customers.l
 └── layer.toml                    # the project's name, description and database
 ```
 
 Each file is named after its predicate and opens with front matter (`name`, the predicate; `description`, what its rows are), then imports what it builds on by folder, file and predicate, then orders its predicate with `@OrderBy`. A database table is referenced by its lowercase database name in `tables/`, and everything else builds on the PascalCase predicate that maps it:
 
-`tables/Orders.l`
+`tables/orders.l`
 
-```logica
+```synalog
 ---
 name: Orders
 description: One row per order, with its customer, amount and status.
@@ -268,41 +268,41 @@ Orders(order_id:, customer_id:, amount:, status:) :-
   orders(order_id:, customer_id:, amount:, status:);
 ```
 
-`concepts/Customer.l`
+`concepts/customer.l`
 
-```logica
+```synalog
 ---
 name: Customer
 description: Every customer who placed at least one order.
 ---
-import tables.Orders.Orders;
+import tables.orders.Orders;
 
 @OrderBy(Customer, "customer_id");
 Customer(customer_id:) distinct :- Orders(customer_id:);
 ```
 
-`rules/CustomerRevenue.l`
+`rules/customer_revenue.l`
 
-```logica
+```synalog
 ---
 name: CustomerRevenue
 description: Total amount ordered by each customer, all statuses included.
 ---
-import concepts.Customer.Customer;
-import tables.Orders.Orders;
+import concepts.customer.Customer;
+import tables.orders.Orders;
 
 @OrderBy(CustomerRevenue, "customer_id");
 CustomerRevenue(customer_id:, total? += amount) distinct :-
   Customer(customer_id:), Orders(customer_id:, amount:);
 ```
 
-Imports resolve from the project's folder, so every file runs on its own: `synalog rules/CustomerRevenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
+Imports resolve from the project's folder, so every file runs on its own: `synalog rules/customer_revenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
 
 ### Named arguments
 
 Synalog uses **named arguments only** (no positional arguments). The left side of `:` is the column name, the right side is the variable:
 
-```logica
+```synalog
 # column "amount" bound to variable "total"
 Orders(amount: total)
 
@@ -314,7 +314,7 @@ Orders(amount:)
 
 Variables are defined with `==`. Arithmetic, string and comparison operators are supported:
 
-```logica
+```synalog
 OrderWithTax(order_id:, total:) :-
   Orders(order_id:, amount:),
   total == amount * 1.10;
@@ -326,7 +326,7 @@ OrderWithTax(order_id:, total:) :-
 
 Aggregation uses the `distinct` keyword and special operators in the rule head:
 
-```logica
+```synalog
 # Sum
 Revenue(total? += amount) distinct :- Orders(amount:);
 
@@ -350,7 +350,7 @@ TopSeller(name? ArgMax= name -> revenue) distinct :- Sales(name:, revenue:);
 
 ### Logical operators
 
-```logica
+```synalog
 # Conjunction (AND), comma
 Result(x:, y:) :- TableA(x:), TableB(x:, y:);
 
@@ -363,14 +363,14 @@ Inactive(user_id:) :- Users(user_id:), ~Logins(user_id:);
 
 Multiple rule definitions for the same predicate combine results (union):
 
-```logica
+```synalog
 HighValue(user_id:) :- Orders(user_id:, amount:), amount > 10000;
 HighValue(user_id:) :- Referrals(user_id:, tier: "vip");
 ```
 
 ### Conditionals
 
-```logica
+```synalog
 OrderSize(order_id:, size:) :-
   Orders(order_id:, amount:),
   size == (if amount > 1000 then "large"
@@ -382,7 +382,7 @@ OrderSize(order_id:, size:) :-
 
 Directives control predicate behavior and **must be placed before** the rule definition:
 
-```logica
+```synalog
 @OrderBy(TopCustomers, "total", "DESC");
 @Limit(TopCustomers, 10);
 TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, amount:);
@@ -400,7 +400,7 @@ TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, am
 
 Functors let you reuse predicate logic by parameterizing input predicates:
 
-```logica
+```synalog
 # Define a reusable pattern
 @OrderBy(SegmentRevenue, "segment_id");
 SegmentRevenue(segment_id:, total? += amount) distinct :-
@@ -416,7 +416,7 @@ SMBRevenue := SegmentRevenue(Segment: SMBCustomers);
 
 Recursive predicates compute transitive closures, for example finding all managers above an employee:
 
-```logica
+```synalog
 @Recursive(AllManagers, 20);
 
 # Base case: direct manager
@@ -434,7 +434,7 @@ Useful for: referral chains, org charts, product taxonomies, bill of materials.
 
 Find shortest paths in weighted graphs by enumerating route costs recursively, then keeping the minimum per destination with a `Min=` aggregation:
 
-```logica
+```synalog
 # Enumerate route costs from the origin, hop by hop.
 @Recursive(RouteCost, 10);
 RouteCost(destination:, cost:) :-
@@ -453,7 +453,7 @@ ShippingCost(destination:, total? Min= cost) distinct :- RouteCost(destination:,
 
 When working with timestamps or dates, always convert to string first:
 
-```logica
+```synalog
 @OrderBy(MonthlyOrders, "month");
 MonthlyOrders(month:, count? += 1) distinct :-
   Orders(created_at:),
@@ -467,7 +467,7 @@ RecentOrders(order_id:) :-
 
 `Today(date:)` (today's date as `"YYYY-MM-DD"`) and `Now(timestamp:)` (the current instant as the engine's native timestamp) are built-in concepts. They are inlined per dialect by the compiler, with no runtime table needed, so they work on every engine. `Now` is the most precise value; derive coarser parts (date, time, hour) from it through the `ToString` → `Substr` pipeline. Join against `Today` whenever a rule needs "today":
 
-```logica
+```synalog
 @OrderBy(ThisMonthOrders, "order_id");
 ThisMonthOrders(order_id:, created_at:) :-
   Orders(order_id:, created_at:),
@@ -481,7 +481,7 @@ They are reserved names: you cannot redefine, extend, or update them.
 
 Entities and relationships become node and edge concepts, and rules traverse them. Edges join **through** the node concepts rather than the raw table, so a filter on a node applies to every edge built on it:
 
-```logica
+```synalog
 @OrderBy(Person, "person_id");
 Person(person_id:, name:, profile_url:) distinct :- Employees(person_id:, name:, profile_url:);
 
@@ -494,7 +494,7 @@ WorksIn(person_id:, department_id:) distinct :-
 
 Relationships with a lifetime carry it as a half-open interval `[valid_from, valid_to)`, using `"9999-12-31"` as the open end so ISO strings compare correctly, and `Today` supplies the clock for point-in-time questions:
 
-```logica
+```synalog
 @OrderBy(CurrentEmployment, "person_id");
 CurrentEmployment(person_id:, company_id:, role:) distinct :-
   EmployedAt(person_id:, company_id:, role:, valid_from:, valid_to:),

{synalog-2.1.0 → synalog-2.2.0}/docs/assertions.md

@@ -9,7 +9,7 @@ Assertions are written in first-order logic, not in Synalog. A rule and its asse
 
 ## A first assertion
 
-```logica
+```synalog
 Parent(x:, y:) :- parents(parent: x, child: y);
 
 @Assert(Ancestor,
@@ -48,7 +48,7 @@ Carol is Alice's grandchild, Erin is Carol's, but Erin is Alice's great-grandchi
 
 `@Assert` takes the predicate the properties are about, then one named argument per property: the name identifies the property in reports, the string is the statement.
 
-```logica
+```synalog
 @Assert(Revenue,
       one_row_per_customer: "∀ c r s, Revenue c r → Revenue c s → r = s",
       positive:             "∀ c, Revenue c > 0");
@@ -57,6 +57,7 @@ Carol is Alice's grandchild, Erin is Carol's, but Erin is Alice's great-grandchi
 - A predicate may have several `@Assert` annotations; a name may appear only once per predicate.
 - A statement that spans several lines goes in a triple-quoted string (`"""..."""`).
 - An assertion can be written before its predicate exists: it waits, as `pending`, until the predicate is defined. Write the contract first.
+- Once its predicate exists, an assertion naming a predicate that nothing defines or imports is a warning: a misspelled name, or a missing import, would leave it pending, never checked.
 - Assertions do not change the generated SQL.
 
 ## The statement language
@@ -74,7 +75,7 @@ Statements are written as [Lean](https://lean-lang.org/) propositions, with the
 | `+`, `-`, `*`, `/` | | arithmetic |
 | `∑ x, t` | `sum x, t` | sum of `t` over `x` |
 
-```logica
+```synalog
 @Assert(Revenue, consistent: """forall c r s,
                                 Revenue c r -> Revenue c s -> r = s""");
 ```
@@ -92,7 +93,7 @@ A name bound by a quantifier is a variable; an unbound lowercase name is univers
 
 The properties worth stating are the ones a rule can silently get wrong. All of these run as written against the tables `orders(order_id, customer_id, amount, status)` and `customers(customer_id, country)`:
 
-```logica
+```synalog
 Order(order_id:, customer_id:, amount:, status:) :- orders(order_id:, customer_id:, amount:, status:);
 Customer(customer_id:, country:) :- customers(customer_id:, country:);
 

synalog-2.2.0/docs/assets/synalog-dark.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 100 100" role="img" aria-label="Synalog">
+  <title>Synalog</title>
+  <!-- A Hilbert curve of order 3: one line made of smaller copies of itself. -->
+  <defs>
+    <linearGradient id="synalog" gradientUnits="userSpaceOnUse" x1="14.86" y1="14.86" x2="85.14" y2="85.14">
+      <stop offset="0" stop-color="#f0e3fb"/>
+      <stop offset="1" stop-color="#a271d6"/>
+    </linearGradient>
+  </defs>
+  <path d="M14.86 14.86 L14.86 24.90 L24.90 24.90 L24.90 14.86 L34.94 14.86 L44.98 14.86 L44.98 24.90 L34.94 24.90 L34.94 34.94 L44.98 34.94 L44.98 44.98 L34.94 44.98 L24.90 44.98 L24.90 34.94 L14.86 34.94 L14.86 44.98 L14.86 55.02 L24.90 55.02 L24.90 65.06 L14.86 65.06 L14.86 75.10 L14.86 85.14 L24.90 85.14 L24.90 75.10 L34.94 75.10 L34.94 85.14 L44.98 85.14 L44.98 75.10 L44.98 65.06 L34.94 65.06 L34.94 55.02 L44.98 55.02 L55.02 55.02 L65.06 55.02 L65.06 65.06 L55.02 65.06 L55.02 75.10 L55.02 85.14 L65.06 85.14 L65.06 75.10 L75.10 75.10 L75.10 85.14 L85.14 85.14 L85.14 75.10 L85.14 65.06 L75.10 65.06 L75.10 55.02 L85.14 55.02 L85.14 44.98 L85.14 34.94 L75.10 34.94 L75.10 44.98 L65.06 44.98 L55.02 44.98 L55.02 34.94 L65.06 34.94 L65.06 24.90 L55.02 24.90 L55.02 14.86 L65.06 14.86 L75.10 14.86 L75.10 24.90 L85.14 24.90 L85.14 14.86" fill="none" stroke="url(#synalog)" stroke-width="5.71" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

synalog-2.2.0/docs/assets/synalog-light.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 100 100" role="img" aria-label="Synalog">
+  <title>Synalog</title>
+  <!-- A Hilbert curve of order 3: one line made of smaller copies of itself. -->
+  <defs>
+    <linearGradient id="synalog" gradientUnits="userSpaceOnUse" x1="14.86" y1="14.86" x2="85.14" y2="85.14">
+      <stop offset="0" stop-color="#4e2275"/>
+      <stop offset="1" stop-color="#b07ddb"/>
+    </linearGradient>
+  </defs>
+  <path d="M14.86 14.86 L14.86 24.90 L24.90 24.90 L24.90 14.86 L34.94 14.86 L44.98 14.86 L44.98 24.90 L34.94 24.90 L34.94 34.94 L44.98 34.94 L44.98 44.98 L34.94 44.98 L24.90 44.98 L24.90 34.94 L14.86 34.94 L14.86 44.98 L14.86 55.02 L24.90 55.02 L24.90 65.06 L14.86 65.06 L14.86 75.10 L14.86 85.14 L24.90 85.14 L24.90 75.10 L34.94 75.10 L34.94 85.14 L44.98 85.14 L44.98 75.10 L44.98 65.06 L34.94 65.06 L34.94 55.02 L44.98 55.02 L55.02 55.02 L65.06 55.02 L65.06 65.06 L55.02 65.06 L55.02 75.10 L55.02 85.14 L65.06 85.14 L65.06 75.10 L75.10 75.10 L75.10 85.14 L85.14 85.14 L85.14 75.10 L85.14 65.06 L75.10 65.06 L75.10 55.02 L85.14 55.02 L85.14 44.98 L85.14 34.94 L75.10 34.94 L75.10 44.98 L65.06 44.98 L55.02 44.98 L55.02 34.94 L65.06 34.94 L65.06 24.90 L55.02 24.90 L55.02 14.86 L65.06 14.86 L75.10 14.86 L75.10 24.90 L85.14 24.90 L85.14 14.86" fill="none" stroke="url(#synalog)" stroke-width="5.71" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

{synalog-2.1.0 → synalog-2.2.0}/docs/cli.md

@@ -99,16 +99,16 @@ duckdb and the PostgreSQL driver ship with synalog. For the other engines (`bigq
 
 ### Imports
 
-In a project, `import <folder>.<Name>.<Name>;` statements resolve from the project's folder (the one holding `layer.toml`), whichever file runs and wherever from: `import tables.Orders.Orders;` reads the project's `tables/Orders.l`. The program file's directory and the current directory come next. Pass `--import-root DIR` (repeatable) to search elsewhere; explicit roots replace the defaults.
+In a project, `import <folder>.<name>.<Name>;` statements resolve from the project's folder (the one holding `layer.toml`), whichever file runs and wherever from: `import tables.orders.Orders;` reads the project's `tables/orders.l`. The program file's directory and the current directory come next. Pass `--import-root DIR` (repeatable) to search elsewhere; explicit roots replace the defaults.
 
-In the [`shop` project](language/index.md), `rules/TopCustomers.l` builds on `rules/CustomerRevenue.l`:
+In the [`shop` project](language/index.md), `rules/top_customers.l` builds on `rules/customer_revenue.l`:
 
-```logica
---8<-- "docs/examples/shop/rules/TopCustomers.l"
+```synalog
+--8<-- "docs/examples/shop/rules/top_customers.l"
 ```
 
 ```console
-$ synalog rules/TopCustomers.l run TopCustomers --load orders=data/orders.csv
+$ synalog rules/top_customers.l run TopCustomers --load orders=data/orders.csv
 +-------------+-------+
 | customer_id | total |
 +-------------+-------+
@@ -118,7 +118,7 @@ $ synalog rules/TopCustomers.l run TopCustomers --load orders=data/orders.csv
 2 rows
 ```
 
-`import rules.CustomerRevenue.CustomerRevenue as Revenue;` imports the same predicate under another name. Directives attached to an imported predicate (its `@OrderBy` here) travel with it.
+`import rules.customer_revenue.CustomerRevenue as Revenue;` imports the same predicate under another name. Directives attached to an imported predicate (its `@OrderBy` here) travel with it.
 
 ### Errors
 
@@ -198,7 +198,7 @@ $ synalog introspect
 Wrote 2 table file(s) to /path/to/sales/tables
 ```
 
-```logica
+```synalog
 ---
 name: PublicOrders
 description: Orders.

{synalog-2.1.0 → synalog-2.2.0}/docs/differences-datalog.md

@@ -19,7 +19,7 @@ Synalog belongs to the [Datalog](https://en.wikipedia.org/wiki/Datalog) family:
 
 Datalog identifies arguments by position: `edge(X, Y)` means whatever the first and second columns happen to be. Synalog uses [named arguments](language/syntax.md#named-arguments) exclusively:
 
-```logica
+```synalog
 # Datalog: positional, not supported
 # edge(X, Y) :- node(X), node(Y), link(X, Y).
 
@@ -39,7 +39,7 @@ The trade is deliberate: you give up an incremental in-memory engine and gain th
 
 A Datalog relation is a *set*: duplicates cannot exist. Synalog inherits SQL's *multiset* semantics: a rule body that matches a row twice produces it twice, and the union operator `|` is a `UNION ALL`. Deduplication is opt-in with the `distinct` keyword:
 
-```logica
+```synalog
 # Set semantics, as in Datalog: duplicates removed
 Customer(customer_id:) distinct :- Orders(customer_id:);
 ```
@@ -50,7 +50,7 @@ This is why the documentation marks concepts and aggregating rules `distinct` th
 
 Pure Datalog restricts terms to constants and variables, with no function symbols, which is exactly what guarantees its termination. Synalog drops that restriction: rule bodies can compute with [arithmetic, string and comparison operators](language/syntax.md#operators), [conditionals](language/syntax.md#conditionals), [records](language/syntax.md#records), arrays, [built-in functions](language/functions.md) and [user-defined functions](language/functions.md#user-defined-functions):
 
-```logica
+```synalog
 OrderSize(order_id:, size:) :-
   Orders(order_id:, amount:),
   size == (if amount > 1000 then "large" else "small");
@@ -60,7 +60,7 @@ OrderSize(order_id:, size:) :-
 
 Core Datalog has no aggregation; systems that add it bolt it on with varying syntax and semantics. In Synalog [aggregation](language/aggregation.md) is part of the rule head: `+=`, `Min=`, `Max=`, `Avg=`, `List=`, `Set=`, `ArgMax=` and more:
 
-```logica
+```synalog
 @OrderBy(CustomerSpend, "total", "DESC");
 CustomerSpend(customer_id:, total? += amount) distinct :- Orders(customer_id:, amount:);
 ```
@@ -71,7 +71,7 @@ The non-aggregated head columns act as the grouping key, like SQL's `GROUP BY`.
 
 Datalog recursion always terminates because the Herbrand universe is finite: no function symbols means no new values can ever be created. Synalog's expressions break that guarantee (a recursive rule can compute `cost + hop` forever), so [recursion](language/recursion.md) requires an explicit iteration bound via the [`@Recursive` directive](language/directives.md#recursive):
 
-```logica
+```synalog
 @Recursive(AllManagers, 20);
 AllManagers(employee_id:, manager_id:) :- Employees(employee_id:, manager_id:);
 AllManagers(employee_id:, manager_id:) :-
@@ -85,7 +85,7 @@ The limit bounds the number of hops, so even cyclic graphs terminate. For a clos
 
 Datalog answers are unordered sets, with no notion of "the first ten results". Synalog adds [`@OrderBy` and `@Limit`](language/directives.md) so results are deterministic and pageable, which is what lets an agent with a limited context window walk a large result set page by page:
 
-```logica
+```synalog
 @OrderBy(TopCustomers, "total DESC");
 @Limit(TopCustomers, 10);
 TopCustomers(customer_id:, total:) :- CustomerSpend(customer_id:, total:);
@@ -97,7 +97,7 @@ This is also why `@OrderBy` is mandatory on every concept and rule: without it,
 
 Datalog predicates are first-order: a rule cannot take another predicate as a parameter. Synalog's [functors](language/functors.md) allow exactly that, instantiating a generic rule with different predicates:
 
-```logica
+```synalog
 EnterpriseRevenue := SegmentRevenue(Segment: EnterpriseCustomer);
 SMBRevenue        := SegmentRevenue(Segment: SMBCustomer);
 ```
@@ -112,7 +112,7 @@ The classic Datalog safety conditions, range restriction (every head variable bo
 
 Datalog has no way to state, next to a predicate, what it should satisfy; some engines accept integrity constraints, written as Datalog rules that must derive nothing. New in Synalog 2.0, and found in neither Datalog nor Logica, `@Assert` states a property in first-order logic, with quantifiers, implication and sums, in a notation distinct from the rules:
 
-```logica
+```synalog
 @Assert(Ancestor,
       transitive:  "∀ x y z, Ancestor x y → Ancestor y z → Ancestor x z",
       irreflexive: "∀ x, ¬ Ancestor x x");

{synalog-2.1.0 → synalog-2.2.0}/docs/differences.md

@@ -6,7 +6,7 @@ Synalog is a fork of [Logica](https://logica.dev/) with a fast Rust core. It kee
 
 Synalog doesn't support positional attributes like Logica or Datalog: it only uses **named attributes**, which reduce agent mistakes. This feature is optional in Logica; Synalog makes it mandatory.
 
-```logica
+```synalog
 # Synalog: always named
 Employee(name:, salary:)
 
@@ -30,7 +30,7 @@ Synalog embeds a [formal verifier](verification.md) that catches structural erro
 
 New in Synalog 2.0, and not in Logica: `@Assert` states what a predicate must satisfy, in first-order logic written as [Lean](https://lean-lang.org/) propositions, and Synalog checks it against the data by searching for counterexamples. `synalog program.l verify` reports the assertions that are violated, and `run` refuses a program that violates one.
 
-```logica
+```synalog
 @Assert(Ancestor, transitive: "∀ x y z, Ancestor x y → Ancestor y z → Ancestor x z");
 ```
 

{synalog-2.1.0 → synalog-2.2.0}/docs/engines.md

@@ -12,7 +12,7 @@ Synalog compiles to seven SQL dialects. Select the target with the `@Engine` ann
 | Presto | `presto` | |
 | Databricks | `databricks` | Double-quoted string literals |
 
-```logica
+```synalog
 @Engine("psql");
 ```
 

synalog-2.1.0/docs/examples/shop/concepts/Customer.l → synalog-2.2.0/docs/examples/shop/concepts/customer.l

@@ -3,7 +3,7 @@ name: Customer
 description: Every customer who placed at least one order.
 keywords: [customer, buyer, client]
 ---
-import tables.Orders.Orders;
+import tables.orders.Orders;
 
 @OrderBy(Customer, "customer_id");
 Customer(customer_id:) distinct :- Orders(customer_id:);

synalog-2.1.0/docs/examples/shop/concepts/OrderStatus.l → synalog-2.2.0/docs/examples/shop/concepts/order_status.l

@@ -2,7 +2,7 @@
 name: OrderStatus
 description: The statuses an order can have (shipped, pending, cancelled).
 ---
-import tables.Orders.Orders;
+import tables.orders.Orders;
 
 @OrderBy(OrderStatus, "status");
 OrderStatus(status:) distinct :- Orders(status:);

synalog-2.1.0/docs/examples/shop/rules/CustomerRevenue.l → synalog-2.2.0/docs/examples/shop/rules/customer_revenue.l

@@ -3,8 +3,8 @@ name: CustomerRevenue
 description: Total amount ordered by each customer, all statuses included.
 keywords: [revenue, spend, sales]
 ---
-import concepts.Customer.Customer;
-import tables.Orders.Orders;
+import concepts.customer.Customer;
+import tables.orders.Orders;
 
 @OrderBy(CustomerRevenue, "customer_id");
 CustomerRevenue(customer_id:, total? += amount) distinct :-

synalog-2.1.0/docs/examples/shop/rules/OrdersByStatus.l → synalog-2.2.0/docs/examples/shop/rules/orders_by_status.l

@@ -2,8 +2,8 @@
 name: OrdersByStatus
 description: Number of orders per status.
 ---
-import concepts.OrderStatus.OrderStatus;
-import tables.Orders.Orders;
+import concepts.order_status.OrderStatus;
+import tables.orders.Orders;
 
 @OrderBy(OrdersByStatus, "status");
 OrdersByStatus(status:, count? += 1) distinct :- OrderStatus(status:), Orders(status:);