# Dyalog APL versions

(Redirected from Dyalog APL 16.0)

Dyalog APL is released in numbered versions, with approximately one version per year. Each release version is classified as a major (.0) or minor (point) release, depending on whether the major version number is incremented. Major versions are more likely to introduce new features and may spend longer in development.

## 10.0

Version 10.0 was released March 2003. It incorporated aspects of .NET support that had been part of Dyalog.NET, as well as other miscellaneous improvements to the language, interface, and performance.

The new constant value `⎕NULL` was added for better integration with .NET. Another new system function, `⎕NLOCK`, was added for file locking support. Two features were added to `:For` loops: the `:InEach` keyword for iterating simultaneously along several arrays, and automatic handling of .NET COM collections.

This release added keyword completion (AutoCompletion) and syntax colouring in the session. New performance features were added: recognised idioms were combinations of tokens supported by special code, and binding a search function (Index of or Membership) to its principal argument invoked the new retained hash table mechanism, saving the work of creating a hash table for that argument every time the search function was called after the first. The APLScript mechanism, allowing source files to be converted to workspaces for distribution, was also added. The resulting executables could be distributed with a copy of Dyalog APL in library form.

## 10.1

Version 10.1 was released July 2004. It allowed tradfn arguments and results to be composed of multiple variables (much like stranding) and featured improved thread handling, including a token pool mechanism for synchronisation. In preparation for the upcoming 64-bit release in version 11.0, it added support for 64-bit component files, which increased the 4GB limit on component file sizes imposed by 32-bit files.

System functions `⎕TPUT` and `⎕TGET` were added to manage threads, along with the system variable `⎕TPOOL` and function `⎕TREQ` to report on existing threads and requests. The current thread name can be found with the new system function `⎕TNAME`.

File handling system functions such as `⎕FCREATE` were extended to allow 0 as an input tie number, to indicate that the smallest available tie number should be used (0 is not a valid option). The release also featured further improvements to the session such as filename completion for workspace commands.

## 11.0

Version 11.0 was released October 2006, and was released for both 32- and 64-bit systems—Dyalog's first 64-bit release aside from a much earlier DEC Alpha release. It introduced object-oriented programming extensions designed to work like .NET and based technologically on the existing namespaces. The primary new features were classes, instances (objects), and interfaces, supporting inheritance, access control, and constructors and destructors. Instances could be placed in arrays, and empty arrays could store the class of an instance in the prototype. When instantiated (for instance by taking the First element of an empty array), a prototype object would be created using the class's niladic constructor, if present. Classes could interact with namespaces by importing their functions as methods. Dyalog's Windows GUI framework, already based on .NET classes, was integrated with the new Dyalog classes.

New Quad names were added to support object-oriented programming: the system functions `⎕NEW`, `⎕CLASS`, `⎕INSTANCES`, and `⎕DF`, and system variables `⎕BASE` and `⎕THIS`. Additionally, system functions `⎕FIX` and `⎕SRC` were added to support namespace scripts.

Dyalog 11.0 also included primitive extensions:

• Index (`⌷`), possibly with axis, was added. A monadic case, called Materialise, was also introduced in order to get a class's default property.
• The Power (`⍣`) operator was added, with support for inverses.
• And (`∧`) and Or (`∨`) were extended to non-Booleans as the LCM and GCD functions, respectively.

## 12.0

Version 12.0 was released in August 2008. It introduced full Unicode support to Dyalog APL, so that all character data in the new Unicode edition consisted of Unicode code points. However, a Classic edition without Unicode (retaining Dyalog's old APL character set) was also released. As of version 18.0, every later Dyalog release has included both Classic and Unicode interpreters. Unicode characters were supported by three new internal types: 1-byte, 2-byte, or 4-byte code points could be used depending on the maximum code point in the string. In each case a single element is a single code point, so the 1-byte and 2-byte encodings are compressed versions of UTF-32, and are unrelated to variable-width encodings like UTF-8 and UTF-16. This change affected the way character data was sorted, because Dyalog's character set did not have the same ordering as Unicode. The change to Unicode allowed a more standard way of implementing keyboard input to be used.

In support of Unicode, the new system functions `⎕AVU` (a Unicode version of `⎕AV`) and `⎕UCS` (Unicode Convert) were added. Two other system functions `⎕FCOPY` (Copy File) and `⎕FPROPS` (File Properties) were also added.

The new version integrated Causeway tools including SharpPlot with the interpreter. Dyalog had purchased these tools in April 2007. It also marked the official adoption of SALT (Simple APL Library Toolkit) as a way to distribute code; SALT had been included in version 11.0 as an experimental feature. Component files were enhanced both with Unicode support and file journalling to improve recovery.

## 12.1

Version 12.1 was released in November 2009. Although it was a minor release, developed alongside the much more ambitious version 13.0, it still included new language features in addition to improvements to the language environment and .NET integration.

The primitive function Table (`⍪`) from ISO/IEC 13751:2001, was added, as well as the I-beam operator (`⌶`). I-beams for syntax colouring, parallel execution control, memory manager statistics, and exporting the workspace to .NET were provided; many more have been added since. Additionally, the system functions `⎕XML`, for converting data to and from XML, and `⎕FCHK`, to check and repair component files, were added. The way the Outer Product operator computes the prototype of an empty result was changed: rather than using the right argument's prototype, in 12.1 it calls the operand once on the argument prototypes to determine the result prototype.

## 13.0

Version 13.0 was released in April 2011. It featured extensive changes to the language including support for complex and decimal float numeric types, identity function primitives, support for regular expressions, extensions to existing primitives, and new idioms.

Support for complex numbers including numeric literal notation such as `3J4`, arithmetic and circle functions, and tolerant comparisons Equal and Not Equal (but not array ordering: total array ordering including ordering of complex numbers was added in 17.0). While almost all changes were backwards compatible, backwards compatibility in the Power function was broken: fractional powers of negative numbers, such as `¯8 * ÷3`, could return different results.

Support was added for 128-bit decimal floating point numbers (from IEEE 754-2008), using the densely packed decimal (DPD) format internally. The system variable `⎕FR` (Floating point Representation) was added, with the options 645 for 64-bit binary (5) floats and 1287 for 128-bit decimal (7) floats. Because of the increased precision of decfs, an additional system variable `⎕DCT` was added to control comparison tolerance with decfs enabled, with the default value `1E¯28`. When `⎕FR` is 645, `⎕CT` controls the comparison tolerance, but when it is 1287, `⎕DCT` controls comparison tolerance. Support for interfacing with .NET decimal floats was also added. Because no complex decimal float type was added, version 13.1 broke Dyalog APL's strict numeric type hierarchy, introducing potential changes in precision when placing values together in an array.

Identity functions `⊣` (Same, Left) and `⊢` (Same, Right) were introduced. Monadic `+`, formerly called Identity, was changed to Conjugate (a change which did not break backwards compatibility, because prior to the introduction of complex numbers the two functions were indistinguishable). Dyadic functions Take (`↑`), Drop (`↓`), and Index (`⌷`) were extended to allow short left arguments, matching SHARP APL's interpretation of the leading axis theory.

A primitive operator (`⍠`) was introduced as an alternative spelling of the existing system operator Variant (`⎕OPT`), with a functionality similar to one sketched by Ken Iverson (`:`)[1] and implemented in J (`!.`).

The Index Generator function was changed so that `⍳⍬` would return `⊂⍬` rather than `⎕IO`. The former behaviour was considered a bug because `⎕IO` is not a valid index into an array with empty shape (that is, a scalar).

System operators `⎕S` and `⎕R` were added to perform regex search and replace, respectively. The system function `⎕RSI` (Reference Space Indicator) was implemented to return references to the namespaces from which functions were called: `⎕RSI` is identical to `⎕NSI` but returns namespace references instead of string names. System function `⎕PROFILE` was added for line-level profiling of APL applications.

Dyalog's Input Method Editor (IME), used to control keyboard layouts, was redesigned.

Idiom recognition was improved: the append idiom `,←` was extended and a new append idiom `⍪←` was added, as well as a new join idiom `⍪/`. Tack-reduce idioms `⊣⌿`, `⊣/`, `⊢⌿`, and `⊢/` to obtain the first or last major cell of an array, or the first or last column of a matrix, were added. Euler's idiom `*○`, producing a unit complex number, was also added.

Dyadic Grade with a bound left argument was improved by allowing a retained hash of that left argument, in order to avoid reprocessing it during every invocation of Grade.

A new error message, INTERNAL ERROR (99) was added. Several I-beams related to Unix forks were added.

## 13.1

Version 13.1 was released in April 2012.

Error messages were extended with the potential for additional information beyond the type of error. The system variable `⎕DMX` (Diagnostic Message eXtended) was added to access this information programmatically, as well as a help URL and the source code location corresponding to the error. The system function `⎕FHIST`, to access information about a file's history (such as time of creation), was also added.

New random number generators were added: the Mersenne twister algorithm, and querying the operating system. The algorithm could be selected with I-beam `16807⌶`. Support was added for Enlist in selective assignment.

New idioms `0=⊃⍴` and `0≠⊃⍴` (valid for `⎕ML<2`) were added. Idiom support was backported to 13.0 as well.

Replicate was extended to allow extension of any right argument with length 1 along the replication axis, and not just a singleton right argument, matching APL2's conformability rules for Replicate.

## 13.2

Version 13.2 was released in January 2013. It included GUI improvements, a new Array Editor, and minor improvements in the language and implementation.

Selective assignment was was extended to allow bracket indexing and the Each operator, in order to match APL2 behaviour.

Performance of reductions, scans, and stranding was improved. In particular, stranding and the scans `≤\`, `>\`, `≥\`, `⍱\`, and `⍲\` were all improved asymptotically, from ${\displaystyle O(n^{2})}$ to ${\displaystyle O(n)}$ time in the length of the argument or number of stranded arrays.

## 14.0

Release announcement, notes (pdf)

Version 14.0 was released in June 2014. It featured extensive changes to the Dyalog APL language as well as its implementation.

Under the direction of Roger Hui, who had been hired by Dyalog Ltd. in 2011, several features adapted from J were added. Version 14.0 began the adoption in Dyalog APL of array programming's leading axis model, with built-ins Tally (`≢`), Key (`⌸`), and the Rank operator (`⍤`). Function trains, another J feature, were also introduced. Of these, Rank differs from J's definition because it does not allow complete leading axis agreement—instead, two arguments must have identical frames or one frame must be empty—and Key has an added monadic case, and differs in that the operand is passed a left argument indicating the unique element used.

Further changes were made in conjunction with the introduction of Rank and leading axis theory. Index Of was extended (as in J) to allow a left argument of rank greater than 1, searching major cells of the left argument. Mix was extended to increase the rank of each element in its argument to a common rank, rather than giving a RANK ERROR if they had unequal ranks. This change brought the behavior of Mix into alignment with the result array combination used by the Rank operator and Key. An unrelated change was to extend Mix with axis to allow the axis to be a vector indicating the final positions of each axis of the argument elements (rather than only a singleton indicating the position of the first axis). This change was made to apply only with a migration level setting of at least 2; it was extended to all migration levels in version 18.0.

This version allowed monadic operators to be manipulated more easily: beginning in 14.0, they can be named, grouped with parentheses, and displayed in the session. It also introduced a new way to form a monadic operator called right operand currying: a dyadic operator along with an operand to its right produces a derived operator. These changes did not extend to naming, parenthesizing, or displaying dyadic operators, nor to binding a left operant to a dyadic operator.

Performance improvements to existing features were focused on Boolean arrays but also included work on indexing and scans. A new I-beam, `8⌶`, was introduced to allow fast lookups on inverted tables, paralleling the extension to Index Of to allow lookups on non-inverted tables.

The default migration level was changed from 0 to 1, with the effect that monadic `∊` indicates Enlist rather than Type by default. The default random link was changed to use the Mersenne Twister algorithm rather than a linear congruential generator. Additionally, the assignment `⎕RL←0` was introduced to initialize random number generation with a seed taken from the operating system (which therefore differs between different APL instances).

Component files were enhanced with usability improvements in the component file system functions and the ability to create zipped (compressed) component files.

## 14.1

Release announcement, notes (pdf)

Version 14.1 was released in June 2015. It added support for Apple Mac OS (now macOS) using the new RIDE session environment, which was also released for Windows and Linux.

Work continued on interfacing with .NET, in particular databinding and a `:Disposable` keyword to help manage object garbage collection.

14.1 added support for control structures and global variables to the bytecode compiler, and other performance improvements including improved evaluation of idioms and other special combinations.

Support for parsing JSON files was added; it would later be turned into the system function `⎕JSON` in version 16.0.

## 15.0

Release announcement, notes (pdf)

Version 15.0 was released in June 2016. It added platform-independent portable file functions (`⎕NEXISTS`, `⎕NINFO`, `⎕NGET`, `⎕NPUT`, `⎕NDELETE`, `⎕MKDIR`, and `⎕NPARTS`) and improved support for using APL source code from text files. It also added I-beams for case conversion and creating hashed arrays which behave identically to normal arrays but have faster performance when searched with set functions including Index-Of (`⍳`) and Membership (`∊`).

Dyalog was made free for personal and non-commercial use starting in version 15.0.

Work on the cross-platform session environment RIDE continued, with version 3.0 released simultaneously with Dyalog 15.0.

## 16.0

Release announcement, notes (pdf)

Version 16.0 was released in June 2017. It added several new primitives as well as tools for working with JSON and CSV files.

The following new primitive functions and operators were added:

Additionally, system functions `⎕JSON` and `⎕CSV` were added to import and export data in common formats. Some JSON support was already present; 16.0 promoted it to a system function.

Work was continued on the RIDE session environment, which was made the default IDE on Linux in addition to macOS. Additionally, the HTMLRenderer and MiServer user interface tools were introduced.

Significant performance improvements were made in structural and selective functions such as Transpose, Catenate, Take, Rotate, and Reverse, and other primitives including Enlist, Encode, and Decode. Work on Dyalog's bytecode compiler was significantly reduced relative to 15.0, a trend which continued with almost no development on the compiler done in 17.0 and later.

## 17.0

Release announcement, notes

Version 17.0 was released in July 2018. It features significant work on tools for using APL and interfacing with other languages, as well as performance, and a relatively small number of new language features.

Total array ordering (TAO) was added in version 17.0, making it the first APL implementation to order entire arrays rather than cells of a single array. This allows Grade Up (`⍋`), Grade down (`⍒`), and Interval Index (`⍸`) to work on nested arrays. Additionally, Unique (`∪`) was extended to allow an argument of any rank by removing duplicate major cells.

17.0 featured improvements to the HTML-based session environment RIDE, and a preliminary version of Link, which was fully released in 17.1. It also improved the positioning of the session's error caret: prior to 17.0 the caret usually pointed to a position further left than the source of an error, while in 17.0 and later it almost always points to the actual primitive or named function or operator which emitted the error, or the beginning of the derived function which did.

Support for packaging APL code as a shared library (for instance a .so or .dll file) for use by other languages was added.

Portable file function support was improved, with changes including new functions `⎕NCOPY` and `⎕NMOVE` to copy and move files.

Version 17.0 implemented substantial performance improvements in many areas. The most important improvements were better use of vector instructions including support for ARM NEON and AVX2 and vectorised comparison functions, simplification of trivial cases for functions, improved Boolean algorithms, and improvements to Replicate, Expand, and Where.

## 17.1

Release announcement, notes

Version 17.1 was released in October 2019, shortly after the Dyalog '19 user meeting. It contains few new features and almost no performance changes. The primary changes to the language were to add the Link system using `]LINK`, allow running Dyalog through docker containers, and improve cross-platform support for HTMLRenderer. Additionally, Dyalog's licensing was changed to allow non-commercial users to download and run it for free, without applying for a non-commercial license from Dyalog.

The Interval Index (`⍸`) primitive was extended to allow duplicate values in the left argument (a feature already present in J, which does not verify that the left argument is sorted).

## 18.0

Version 18.0 was released in June 2020. It was developed in parallel with version 17.1, which had very few new features, and includes several new primitives and extensions to existing primitives.

The following new primitive functions and operators are added:

• Unique Mask (`≠`)
• Atop operator (`⍤`), sharing a symbol with Rank
• Over operator (`⍥`)
• Constant operator (`⍨`), sharing a symbol with Commute

Integers greater than 1 are now allowed in the right argument of Where (`⍸`), matching the definition of the corresponding primitive function in other APLs. A related extension allows integers greater than 1 in the left argument of Partitioned Enclose (`⊂`), which produce empty partitions in the output. The extension to Partitioned Enclose makes it the first APL partitioning function which can produce empty partitions.

Version 18.0 allows enabling multi-line input in the session using the line editor, and allows control structures to be used in the session. Multi-line input is begun when a dfn, namespace, class, or control structure is begun but not finished on the same line. It also allows syntax colouring and editing multi-line blocks in the session.

New and extended system functions for case folding and mapping (`⎕C`) and date-time conversion are added.

Initial support for .NET Core, Microsoft's cross-platform successor to the original .NET framework, has been added.

## References

1. Kenneth E. Iverson, A Dictionary of APL, VI. Conjunctions, Custom. APL Quote Quad, Volume 18, Number 1, 1987-09.
APL dialects 
Maintained APL+WinAPL2APL64APL\ivApletteAprilCo-dfnsDyalog APLdzaima/APLExtended Dyalog APLGNU APLKAPNARS2000Pometo
Historical A Programming LanguageA+ (A) ∙ APL#APL\360APL/700APL\1130APL\3000APL.68000APL*PLUSAPL.jlAPL.SVAPLXIverson notationIVSYS/7090NARSngn/aplopenAPLPATRowanSAXSHARP APLRationalized APLVisualAPL (APLNext) ∙ VS APLYork APL
Derivatives AHPLBQNCoSyELIGleeIIvyJJellyJellyfishK (Q, KDB+) ∙ NialRAD
Overviews Timeline of array languagesTimeline of influential array languagesFamily tree of array languages