iyi 0.17.0

About two hundred and thirty fixes, and the windows-0.17.0-3 and
windows-0.17.0-4 branches, many of them found by generated programs
whose answers SPEC.md fixes - 2,680 concurrency programs, and 1,500
multi-module programs built from source and from artifacts. A group
cancels its tasks when its block is left early or its owner is
cancelled, a task spawned on a group whose block has ended is a panic,
select has when timeout(ms), a captured local that a kept block
assigns is refused instead of tearing under a thread, and a line puts
writes from several threads comes out whole. forall and where
bounds, parameterised supertraits, macro hooks, protected and
{{@type}} bodies travel in a .iyimod, and six programs a module's
artifacts could not build now build from them. The language server
completes after any receiver, after X:: and inside an import's braces,
and moving a module's file rewrites the qualified names that spell it.
String#== is ten times faster on long strings, and File.read holds
the file once.

Some programs that compiled are refused: two impls answering one
method on one type, an impl for a module that is not a trait, a trait
requirement answered with other parameters, a reopen replacing a method
another module wrote, ! in initialize, def group, where bounding
nothing, a derive writing a macro hook, and an IyiThread block naming a
constant, a class variable or self that is not Share. Some answers
change: Array#delete removes every equal element, each_with_object
yields the element before the memo, a struct with no == of its own
compares its fields, sample(n) is n distinct elements, zip refuses
a shorter collection, strip takes Unicode whitespace, String#inspect,
Range#to_s and JSON::Any#to_s print as the other library's do, an
iterator yields a nil element, a float converts to an integer by
truncating first, a group's join re-raises the first task that panicked,
and abort runs what the task deferred. .iyimod is v56 - v55 records
a --no-codegen build, v56 carries forall and where bounds - so
every 0.16 artifact is refused and rebuilt.

iyi 0.16.2

About two hundred and sixty fixes, most of them found by comparing iyi
with Crystal, Python, libxml2, expat, PyYAML and the RFCs at scale -
random programs, documents, macro expressions, formatter mutants and
language-server sessions by the hundred thousand - each with a check
proven to fail without it. A when 1..5, a when of a tuple of types
and a when Int32 | String never matched and fell to else; a float
literal passed to a Float32 parameter rounded twice; fmt could change
a program's meaning (a heredoc's last blank line, - 1.abs, the end of a
line inside a string); a --release build wrote artifacts with no object
code; iterator adaptors copied their counts; std/json wrote bytes its
reader refused; std/xml took any byte past 0x7F for a name and wrote
whatever it was handed. Some answers change: Char#whitespace?
includes \v and \f, a negative shift count shifts the other way,
Int#chr takes all of Unicode, a flags enum with every member set prints
All, and std/yaml reads flow merges, tabs after indentation and -
continuations as the spec does.

Windows gains the windows-0.17.0-2 branch's fixes, and a program
there ends while another thread collects. The language server answers at
the cursor's line while a buffer does not compile, renames one method at
a time, and counts signature-help arguments correctly. .iyimod is
still v54, so 0.16.1's artifacts are rebuilt only because the compiler's
version is in their identity.

iyi 0.16.1

Math answers the correctly rounded double. sin, cos, tan,
atan, asin, acos, atan2, hypot and cbrt are CORE-MATH's;
erf, erfc, asinh, acosh, atanh, lgamma and tgamma are the
CORE-MATH routines glibc 2.43 ships, and sinh, cosh, tanh and the
Bessel functions glibc's fdlibm - each held by the math gate to its
reference bit for bit, on Linux, Windows and darwin arm64. sin(1e300)
was 0.0. fma rounds once, and without FMA hardware is three to four
times as fast; bessely0, bessely1, besselj, bessely, isqrt,
pw2ceil, ilogb, logb, scalbn and scalbln arrive. A result can
differ from 0.16.0's in its last bit, and gamma(±0) is ±infinity.

About a hundred and ninety fixes, most of them found by comparing the
library with Python, Crystal and the RFCs on millions of inputs, each
with a check in its module's exercise that is proven to fail without it.
An HTTP server could be killed by a malformed chunked body and took two
conflicting Content-Lengths; one XML entity expanded to a gigabyte;
SemanticVersion comparisons recursed forever; and a program outgrowing
a large buffer beside a running mark could fault. Some answers
change: File.match? speaks the full pattern language - * stays
inside a segment, and [, {, ** and \ are syntax; OptionParser
runs a short bundle (-vq) and sends -q=1 to invalid_option;
CSV.parse reads a blank line as an empty row; UUID.parse refuses a
hyphen out of place; Gzip.decompress reads every member; HTTP refuses
control bytes in a field and an interim 100 is no longer the response.

Windows gains the process, path, link, console, signal and language
server fixes of its branch. .iyimod is still v54, so 0.16.0's
artifacts are rebuilt only because the compiler's version is in their
identity.

iyi 0.16.0

The language takes regex literals and writes JSON itself. /a+b/
in an iyi file compiles once through std/regex, and derive serializable gives a struct or class to_json and from_json, a key
per field (SPEC.md II.4). exit(status), a range of characters and %g
arrive with them. One change breaks source: assigning through ::
(::foo = 1) is a syntax error that names the local's spelling, where
the :: was dropped without a word. And puts of a string that already
ends in a newline writes no second one, as Crystal's does.

Faster, and Math answers glibc's bits. crystal-metric's port is a
gate, and it runs in 0.84 of Crystal 1.21's time (geomean 0.86, three
rounds on one machine). The collector hands a page of chunks out per
carve, marks a small live set inside its stop, keeps the empty arenas a
deep budget will fill again, and marks, sweeps and runs its write
barrier in fewer instructions. Math.exp, pow, log, exp2, log2,
log10, expm1 and log1p are glibc's unfused routines to the last
bit, pow three times as fast as before - a result can differ from
0.15.4's in its last bit. Sorting, hashing, BigInt printing, reading
JSON, Base64 and inflating cost what their input does. A class instance
equals itself and hashes by its address, so a Set of them finds what
was added to it.

Windows answers as the other platforms do. Twenty-two fixes from
running the library and the CLI there: files a program is denied, has
open elsewhere, hides or links to; ports another program holds, large
backlogs, a close under a parked read; Ctrl+Z at a console; paths in
another case, drive-relative and \\?\. Two answers change: a read
Windows refuses is a failure where it was an empty file, and a failed
write panics once. .iyimod is still v54, so 0.15.4's artifacts are
rebuilt only because the compiler's version is in their identity.

iyi 0.15.4

iyi 0.15.4

iyi 0.15.3

iyi 0.15.3

iyi 0.15.2

Two packages can each have a util. A package's modules now live under
its name - its path's last segment, - as _, a /vN left off - so two
packages that each have util.iyi are Pa::Util and Pb::Util rather
than one type both define, which refused any program that required both.
A module whose path already begins with the name, as iyi-web's iyi_web/dsl
does, is where it was; one that does not is reached by a qualified name one
segment longer, Liba::Colors for import .../liba/colors, and code that
spelled it Colors from outside the package writes the longer name now.

A package's reach can be a limit. require PATH vX reaches std/file, C,
or reaches nothing, says what that package may touch outside the language,
in iyi mod reach's words; a version past it is refused by name before
iyi.sum or iyi.mod is written, and get keeps the clause.

Windows collects beside the program, and gates stop flaking. A
collection on Windows marks and sweeps with its helper threads beside the
running program, as on Linux and darwin, and a fiber reading stdin parks
there. std_signal's TERM step, which lost its output file in one run in
three under load, holds - a killer subshell ran the gate's own cleanup -
and so do the language server's and the collector's Windows gates.

iyi 0.15.1

Moving to one keyword is one command. iyi fix . rewrites every
using under a directory before any file compiles - one file's compile
reads the modules it imports - then runs each file's did-you-mean loop and
counts what it rewrote. iyi-web's 59 files went through it in one run and
its 27 tests passed; iyi-web v0.1.1 is that tree, for 0.15.0 and later. A
using the compiler meets now carries the line that replaces it as data:
check -f json hands it over as a suggested_edit, and the language
server offers it as a quick fix.

A package release says what it changed. iyi mod release [VERSION]
compiles the package at HEAD and at its last tag and names every exported
line gone and new; a line gone is a new major, a line new a new minor, and
with VERSION it exits 1 when the version says less than that. And iyi get
now ends an upgrade with what it changed in the lines this project wrote:
each export that changed or went, with the file:line that writes it.

iyi init kemal writes iyi.mod and kemal.iyi, and nothing else -
the project's root module, running as it lands, where it wrote an entry, a
greet.iyi and a test every project began by deleting. And a package's
root module that imports its own submodule is reachable again: the import
wall refused every importer of rel the names of Rel when rel/util
had loaded first.

iyi 0.15.0

One keyword for a module and its names. import X::{a, b} loads a
module and brings those names into scope, import X::* every name it
exports, and import X keeps them qualified - where import X followed by
using X wrote one path twice. using is gone, and this release breaks
source that writes it: the compiler refuses the line and names the one
that replaces it, and iyi fix FILE rewrites a whole file, folding a bare
import of the same module into it. iyi-web's 54 files went through it
and its 27 tests passed.

Packages without writing the manifest by hand. iyi get PATH requires
a package's latest release, @v1.2.0 a version and @main or @<commit>
a commit no tag names, written as its pseudo-version; -u brings every
requirement up and never moves one down, and --check says which are
behind. iyi mod tidy makes iyi.mod and iyi.sum say what the source
imports, replace PATH => ../dir builds a package from a directory, a
/v2 path is the repository's second major version, and require PATH vX as web lets a file write import web/dsl::{get}. And get says what
a package reaches outside the language - the std modules that call C,
File, the C it declares - and what an upgrade adds to that; iyi mod reach lists the build's.

Windows marks with helpers, and more gates measure there. A collection
on Windows marks on its helper threads now, as on Linux and darwin; the
collector race, a TERM from outside and the SQLite driver run there, and
more gates measure their floor there. The parallel marker's proofs fire on every machine
and hold on one core. .iyimod is still v54, so 0.14.1's artifacts are
rebuilt only because the compiler's version is in their identity.

iyi 0.14.1

A server can stop, and be reached more ways. std/signal parks a
fiber until INT or TERM arrives, so a graceful stop is a sibling that
closes the listener and a group that joins what is in flight. std/socket
listens and connects over IPv6 and at a unix socket's path, bounds a
read's and a write's wait with read_timeout_ms and write_timeout_ms,
answers what the peer does as a SocketError rather than a panic, and
lets one fiber read a socket while another writes it. A file seeks, a
package imports the standard library, and each of these ran on Linux,
darwin and Windows before it was called done: the socket gate runs on
all three now, and so do twenty-eight more of the language's gates.

The library is faster where a program ported from Crystal spends its
time. Float64#to_s is Grisu3 and String#to_f Eisel-Lemire, Math.exp
is fdlibm's, Base64 is twice as fast, a pattern of byte classes is
searched without the machine and gsub takes a table, BigInt runs its
limbs through pointers, and a Hash allocates nothing until its first
entry. crystal-metric's suite, ported, ran in 24.87 s where Crystal 1.21
took 26.11 s, on the machine the work was measured on.

Thirty-nine fixes, and one that changes what an artifact is. A symbol
in a module's object code carried the producing build's number for it, so
a consumer that met its symbols in another order compared them wrong; a
unit now reads the linking program's number, and .iyimod is v54: an
artifact written by 0.14.0 is refused, and --emit-iyimod rewrites it.
The rest include a temporary file that a planted symlink could redirect,
a query whose malformed % panicked, a darwin write that made a 0600 file
world-readable, a Windows fiber switch that lost the vector registers a
call keeps, and a collector that handed a live object's chunk to a second
one. std is 68 modules and 40,690 lines.