Merge pull request #105 from t-kalinowski/cran/v0.3.0

CRAN release v0.3.0

Author: t-kalinowski

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: quickr
 Title: Compiler for R
-Version: 0.2.1.9000
+Version: 0.3.0
 Authors@R: c(
     person("Tomasz", "Kalinowski", , "tomasz@posit.co", role = c("aut", "cre")),
     person("Posit Software, PBC", role = c("cph", "fnd"),

NEWS.md

@@ -1,67 +1,45 @@
-# quickr (development version)
+# quickr 0.3.0
 
-- Added support for `as.integer()` coercion from `double`, `logical`, and
-  `integer` values (with `double` truncating towards 0).
+This release adds major new support for linear algebra, local functions,
+`sapply()`, and OpenMP parallelism, along with a broad round of reliability,
+compatibility, and compiler/runtime improvements.
 
-- Added initial matrix/linear algebra handler support from base R, using the
-  same BLAS/LAPACK as R: `%*%`, `t()`, `crossprod()`, `tcrossprod()`,
-  `outer()` (with `FUN="*"`), `%o%`, `forwardsolve()`, `backsolve()`, `diag()`,
-  `t()`, `chol()`, `chol2inv()`, `solve()`, and `qr.solve()`. This includes
-  support for:
+## Major new features
 
-  - `drop()` for rank 0-2 inputs (including singleton matrices).
-  - `svd()` results via `$d`, `$u`, and `$v` (either from `s <- svd(x)` or
-    directly from `svd(x)$d`/`$u`/`$v`).
-  - `.Machine$double.eps`.
-  - `qr.solve()` using the LINPACK QR path (for better compatibility with
-    base R behavior).
-
-  The plan is to add more functions in the future (#77, #79 @mns-nordicals)
-
-- Added support for `cbind()` and `rbind()` for rank-0/1/2 inputs, with scalar
-  recycling only and strict length checks for non-scalar inputs.
-
-- On macOS, quickr will use LLVM flang (`flang-new`) for compilation when
-  available (e.g. `brew install flang`). This is optional and can be disabled
-  with `options(quickr.prefer_flang = FALSE)`.
+### Matrix and linear algebra support
 
-- Added OpenMP parallelization via `declare(parallel())`/`declare(omp())` for
-  `for` loops and `sapply()` calls.
+- Added initial matrix / linear algebra support from base R, using the same
+  BLAS/LAPACK as R. Supported operations now include `%*%`, `t()`,
+  `crossprod()`, `tcrossprod()`, `outer()` with `FUN = "*"`, `%o%`,
+  `forwardsolve()`, `backsolve()`, `diag()`, `chol()`, `chol2inv()`,
+  `solve()`, and `qr.solve()`. (#77, #79, @mns-nordicals)
 
-- Added support for throwing errors with `stop()`. (#86)
+- This also adds support for:
 
-- Added support for `abs()` in size expressions used by `declare(type(...))`
-  (e.g. `declare(type(x = integer(abs(end - start) + 1L)))`).
-
-- Improved `for (... in <iterable>)` lowering, including value iteration
-  (`for (v in x)`) and support for `rev()` wrappers on supported iterables.
-
-- Added support for `tanh()` as a unary intrinsic and `rev()` for reversing
-  rank-0/1 vectors (including bind(c) logicals, preserving `NA` storage where
-  possible).
-
-- Added nested compilation scopes with local declaration emission, enabling
-  block-scoped temporaries (Fortran 2008 `block ... end block`) and local
-  closures (lowered to internal procedures under `contains`), including `sapply()`
-  lowering with host association for captures and support for `simplify = "array"` for
-  higher-rank outputs. Examples:
+  - `drop()` for rank 0-2 inputs, including singleton matrices.
+  - `svd()` results via `$d`, `$u`, and `$v`, whether accessed from
+    `s <- svd(x)` or directly as `svd(x)$d`, `svd(x)$u`, or `svd(x)$v`.
+  - `.Machine$double.eps`.
 
-  - Block-scoped temporary for expression subscripting:
+### Local closures and `sapply()`
 
-    ```r
-    out[1] <- ifelse((x > 0.0)[2, 3], 1.0, 0.0)
-    ```
+- Added support for local closures inside compiled functions, including
+  `sapply()` lowering with host association for captures and support for
+  `simplify = "array"` for higher-rank outputs.
 
-  - Local closure + `sapply()` lowering:
+- Example:
 
-    ```r
-    f <- function(i) x[i] + 1.0
-    out <- sapply(seq_along(out), f)
-    ```
+  ```r
+  f <- function(i) x[i] + 1.0
+  out <- sapply(seq_along(out), f)
+  ```
 
-  This lowering matches R’s “copy-on-modify" semantics: modifications to the variables from the parent scope trigger a copy in the local closure scope.
+* This lowering matches R’s copy-on-modify semantics: modifying variables from
+  the parent scope triggers a copy in the local closure scope.
 
-- Added support for superassignment (`<<-`) inside local closures (lowered to internal procedures) to explicitly mutate variables in the enclosing quick function scope, including `x[i] <<- ...` subset targets. Example:
+* Added support for superassignment (`<<-`) inside local closures, including
+  subset targets such as `x[i] <<- ...`, to explicitly mutate variables in the
+  enclosing quick function scope. For example:
 
   ```r
   apply_boundary_conditions <- function() {
@@ -74,49 +52,112 @@
   apply_boundary_conditions()
   ```
 
-- Added support for `array(data=..., dim=...)` for shape construction in
-  user code and tests.
+* Local closures also support optional arguments with `NULL` defaults,
+  with validation to ensure optional arguments are initialized via `is.null()`
+  before use.
 
-- Added extensive tests + snapshots for local closures, `sapply()`,
-  block-scoped temporaries, and package compilation behavior (internal procedure
-  name collisions).
+### Parallel execution
 
-- Lowered the minimum supported R version to 4.3.0 and added a backport of
-  `declare()` for R < 4.4.0 (#67).
+* Added OpenMP parallelization via `declare(parallel())` / `declare(omp())`
+  for supported `for` loops and `sapply()` calls.
 
-- Fixed `[` subsetting scalars with both `drop=TRUE` and `drop=FALSE`, simplifying
-  to Fortran scalars so subsetted scalars in reductions (e.g., `min(m[1, 1], m[2, 1])`)
-  no longer emit `minval` on scalars (#64).
+### Binding and iteration
 
-- Fixed nested scalar `min()`/`max()` in reductions, so clamp-style expressions
-  like `min(max(x[i], lo), hi)` work reliably.
+* Added support for `cbind()` and `rbind()` for rank-0/1/2 inputs, with scalar
+  recycling only and strict length checks for non-scalar inputs.
 
-- Fixed an issue where subsetting logical arrays could fail when compiling quick
-  functions, e.g. `(x > 0)[2, 3]` (#68).
+* Improved lowering for `for (... in <iterable>)`, including value iteration
+  such as `for (v in x)`, and support for `rev()` wrappers on supported
+  iterables.
 
-- Fixed a crash when compiling chained / fall-through assignments like
-  `a <- b <- 1` (#60).
+## Language and runtime additions
 
-- `quick()` now supports dotted symbols (e.g. `foo.bar`) for arguments, locals,
-  and loop variables. Conflicting names that map to the same Fortran symbol now
-  error (Fortran is case-insensitive).
+* Added support for throwing errors with `stop()`. (#86)
 
-- Fixed C bridge size checks for dotted argument names used in
-  `declare(type(...))` size expressions (e.g. `type(x = double(foo.bar))`).
+* Added support for `as.integer()` coercion from `double`, `logical`, and
+  `integer` values. `double` inputs are truncated toward 0.
 
-- `quick()` now gives a helpful error message when a function argument is used
-  without being declared
-  (i.e. missing `declare(type(arg = ...))`).
+* Added support for `tanh()` as a unary intrinsic.
 
-- Fixed an error in invalid subscript arity reporting, e.g. `x[1, 2, 3]` on a
-  matrix now errors cleanly instead of failing while formatting the message.
+* Added support for `rev()` for reversing rank-0/1 vectors, including bind(c)
+  logicals, preserving `NA` storage where possible.
 
-- Vector-matrix recycling in arithmetic is now restricted to recycling
-  along the first axes only.
+* Added support for `abs()` in size expressions used by `declare(type(...))`,
+  for example:
+  `declare(type(x = integer(abs(end - start) + 1L)))`.
 
-- Local closures now support optional arguments with `NULL` defaults, with
-  validation to ensure optional arguments are initialized (via `is.null()`)
-  before use.
+* Improved support for `array(data = ..., dim = ...)` for shape construction in
+  user code.
+
+## Compiler and lowering improvements
+
+- quickr now supports nested compilation scopes with local declaration
+  emission, enabling block-scoped temporaries and local closures lowered to
+  internal procedures under `contains`.
+
+  - This helps in two ways. First, in large compiled functions, declared intermediate
+    results no longer need to stay live for the full duration of the function,
+    which can reduce peak memory use.
+
+  - Second, it improves handling of large temporaries across compilers. In
+    particular, LLVM flang may place temporary arrays on the stack by default,
+    which can cause problems when those temporaries are large. This work also
+    led to better control over when temporaries need to be emitted as
+    heap allocatable.
+
+* Example of a block-scoped temporary used for expression subscripting:
+
+  ```r
+  out[1] <- ifelse((x > 0.0)[2, 3], 1.0, 0.0)
+  ```
+
+## Reliability, compatibility, and diagnostics
+
+* Added extensive tests and snapshots covering local closures, `sapply()`,
+  block-scoped temporaries, and package compilation behavior, including
+  internal procedure name collisions.
+
+* Fixed `[` subsetting on scalars with both `drop = TRUE` and `drop = FALSE`,
+  simplifying to Fortran scalars so subsetted scalars in reductions such as
+  `min(m[1, 1], m[2, 1])` no longer emit `minval` on scalars. (#64)
+
+* Fixed nested scalar `min()` / `max()` in reductions, so clamp-style
+  expressions like `min(max(x[i], lo), hi)` work reliably.
+
+* Fixed an issue where subsetting logical arrays could fail when compiling
+  quick functions, for example `(x > 0)[2, 3]`. (#68)
+
+* Fixed a crash when compiling chained or fall-through assignments such as
+  `a <- b <- 1`. (#60)
+
+* `quick()` now supports dotted symbols such as `foo.bar` for arguments,
+  locals, and loop variables. Conflicting names that map to the same Fortran
+  symbol now error, since Fortran is case-insensitive.
+
+* Fixed C bridge size checks for dotted argument names used in
+  `declare(type(...))` size expressions, for example
+  `type(x = double(foo.bar))`.
+
+* `quick()` now gives a helpful error when a function argument is used without
+  being declared through `declare(type(arg = ...))`.
+
+* Fixed an error in invalid subscript arity reporting, for example
+  `x[1, 2, 3]` on a matrix now errors cleanly instead of failing while
+  formatting the message.
+
+## Breaking changes
+
+* Vector-matrix recycling in arithmetic is now restricted to recycling along
+  the first axes only.
+
+## Platform and toolchain
+
+* Lowered the minimum supported R version to 4.3.0 and added a backport of
+  `declare()` for R < 4.4.0. (#67)
+
+* On macOS, quickr will use LLVM flang (`flang-new`) for compilation when
+  available, for example after `brew install flang`. This is optional and can
+  be disabled with `options(quickr.prefer_flang = FALSE)`.
 
 # quickr 0.2.1
 
@@ -156,10 +197,11 @@
 - Added workaround for cases where the compiler error message might not
   display correctly in RStudio.
 
-- Improved error message when using case-sensitive variable names (#18, #36, #39)
+- Improved error message when using case-sensitive variable names
+  (#18, #36, #39)
 
-- Added `AGENTS.md` and `scripts/setup_codex.sh` to enable the ChatGPT/Codex agent
-  to run tests in a docker container configured without internet access.
+- Added `AGENTS.md` and `scripts/setup_codex.sh` to enable the ChatGPT/Codex
+  agent to run tests in a docker container configured without internet access.
 
 
 # quickr 0.1.0