| Commit message (Collapse) | Author | Age | Files | Lines |
|---|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
state, record, message, output and argument fields, lets, views, keys
and slices can be i64 (Pure 016 stage 2). An integer literal becomes
an i64 where the other side of an operation, a comparison or an
assignment is one; a literal-only side follows the other, found by
compiling it on trial and rolling back. + - * and negation fail the
event with overflow, / and % floor, and i64(x) and number(n) are the
only way between the two, so a mix is a diagnostic that says so.
The check adds 18 i64 diagnostics, i64 accepted forms (with a 30-deep
chain that must stay linear), an event-by-event program past 2^53
and at the edges, and i64 values in the generated programs.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A condition was any number, non-zero being true: done was a number field,
a view showed 1 for true, and done + 1 was no type error. Now bool is its
own type (Pure 016, module format v6):
- true and false; comparisons, text comparisons, has and ! && || give a
bool. Bools are equal or not; they are no numbers and have no order.
- if, conditional expressions, require, where (folds, walks, filtered
tables) take a bool. Given a number, the diagnostic says how to make
one: "if takes a bool, not a number: compare it, as in n != 0".
- Bool states (state on = false), record fields (done = false), message,
output and argument fields (ok: bool), lets, views and columns.
Interpolation writes true or false. A list is not keyed by a bool.
- The examples' flags are bools (charge's holding, toggle's visible,
tasks' done).
Checks: 20 bool diagnostics, a form using bools everywhere, an app whose
every output shows true and false (states, items, views, columns, text)
and whose replacement turns a number into a bool and back. Models hold
bools and compare them strictly: Python's True == 1 no longer hides a 1
where a true belongs. Generated programs are typed, numbers and bools.
|
| |
|
|
|
|
|
|
|
|
| |
A message's, a group's and a record's fields took a newline or a
semicolon after each, while a value's (Kept { id: 1, t: "a" }, send)
take commas, and the language's own examples declared
message { title: text, points: number } and to: { city: text, zip: u32 },
which did not compile. Now a comma, a newline or a semicolon ends a
declared field too (one after the last as well); without one it says
so.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Adding one field to the board two nodes share (Pure's research 105)
still meant the record, the output, three sends and the code applying
what the other node sent: the sends and the apply named every field.
..source, last in a record value's or a send's braces, gives the fields
not written from the source's fields of the same names: an item (an
index, a let, the item a for walks, list[key]) or the handler's message
(grouped fields by their paths). A record value gives what the source
lacks its default; a send still needs every field. list[i] = Record {
... } sets every field of the item, all of them given; a keyed list's
key does not change, so a value with another key fails the event
(limit) and changes nothing.
Both are the fields written out: the checks compare the modules byte
for byte, and run the key rule in pure-run. Seven diagnostics: a spread
not last, a source that is no item nor this handler's message (also
another handler's message), a spread inside a send's group, a send
field left empty, a whole item missing a field, a value that is no
record. The board now sends { ..at } and applies cards[k] = Card {
..remote }: a new field is written in two places, the record and the
output.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
Growing a board two nodes share (Pure's research 105), one field took
five places, two of them the same list: the output a node sends its
changes on and the input it takes the other's with. A message may now
take the fields of a message input or output declared before, in their
order: input remote = message like changed.
The module is the same as with the fields written out, byte for byte
(checked). An unknown name, one that is no message, the message itself,
and an output taking an input's rows are diagnosed.
|
| | |
|
| |
|
|
|
|
|
|
|
|
| |
list[low .. high], as a fold's or a for's list, is the items whose keys
are from low up to before high (a list keyed by a number), read by key:
distinct(l.item for l in lines[o * 16 .. o * 16 + 16] where
stock[l.item].quantity < t) reads one order's lines, whatever its test
does outside them. It compiles to Pure's sliced folds and walks; an empty
for over a slice still computes its keys. Two diagnostics and an app of
slices are checked.
|
| |
|
|
|
|
|
|
| |
distinct(value for item in list [where condition]) counts the different
values the included items give, compiled to Pure's fold of kind 5 (SQL's
count(distinct ...)). An accepted app walks and folds a keyed list in a
range of its key (where l.id >= start && l.id < start + 16), which Pure
reads by key.
|
| |
|
|
|
|
|
|
|
|
|
| |
let name = value, in a handler, names a number or an index for the rest
of its block; name = value gives it a new value of the same kind; the
walks and folds inside read it. It compiles to Pure's locals (a slot an
event, 0 when it begins, never saved), a slot a let in a handler, so an
order's loop sums into a let and takes stock through an index let without
finding the item again. A let may not be a declared name, another let in
scope or the walked item, and holds no text. Nine diagnostics and an app
of lets are checked.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
view name(argument: type, ...) = ... declares a view that takes u32,
number, bytes or text arguments, read by name in the view, in a table's
filter and columns and in the folds inside them (compiled to FIELD of an
arguments input named name.args that names its view, Pure's kind 6). A
host gives them as the request's query: GET /views/balance?aid=42, and a
table pages as before with from and count. A query compiled with aup
query may take arguments too.
An argument's name may not be a state or another declaration, nor the
table's row, nor from or count (which page a table). Eight diagnostics and
an app of views with arguments (a keyed lookup, a fold, a text, a table
filtered by two of them whose column folds with one, a handler's fold
reading its message) are checked.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
for item in list [where condition] { ... } runs its block in a handler
once for every item the list has, in order, the item an index of the list
(read, changed, removed: a removed item does not skip the next). It
compiles to Pure's EACH; a fold inside reads the walk's item as a fold in
a column reads its row. A for adds nothing to the list it walks, holds no
other for and does not reply, so it ends.
A message field may be a list of a record (lines: list of Line): its rows
arrive as a JSON array of objects and fill a list of their own, named
order.lines in the module, which the handler walks, folds and counts
(order.lines.count) and which is emptied when the event ends. So a
transaction over many rows (an order taking stock line by line, all or
nothing) and a bulk insert are one event. An output sends no rows.
Nine diagnostics and an accepted app (rows in a group, where, a fold over
the rows reading the walk's item, a walk that removes) are checked.
|
| |
|
|
|
|
|
|
| |
aup query APP QUERY -o OUT compiles APP's declarations (records, states,
inputs, handlers) with the views QUERY adds, as one module: the node
checks that its states are the app's and runs the query's view on a
snapshot of the app (PUT and GET /queries/NAME in pure-serve). QUERY may
be - for standard input.
|
| |
|
|
|
|
|
|
|
|
| |
A count, sum, max or min inside a table's column may now name the row the
column is evaluated for: per branch, the sum of its accounts
(sum(a.balance for a in accounts where a.bid == b.bid)), or per account,
how many are richer. The column's row inside the fold compiles to
OUTER_ROW, which Pure's verifier accepts only in a fold that runs in a
column; the fold's own item stays ROW. This is a correlated subquery, the
form SQL writes GROUP BY and self-joins with.
|
|
|
As in Pure and Vega, the top level directories are the parts; aup has one,
the compiler, checked end to end by tests/check.py.
|
