The Algol-24 Programming Language Specification

Algol-24 v0.1.4. Nineteen chapters and three annexes. Every rule is decided — what the language should do — and every rule is claimed by a case: a program in conformance/, a refusal in refusals/, or a reproduction in defects/. spec/spec.sh prints how many there are and checks that each citation resolves; a count written here would only be a second copy to keep in step.

This document describes the language and nothing else. Where the implementation disagrees with it, spec/DEFECTS.md records the difference and carries a program that reproduces it. How the language arrived — the divergences that were closed, the questions that were settled, the changes once planned — is in spec/HISTORY.md.

1. Introduction

Algol-24 is a retro-modern, gradually typed language: classic Pascal syntax over unbounded integers, full Unicode, gradual types, closures and a foreign function interface. This document specifies its lexis, syntax, and semantics.

1.1 Authority

This specification is the authority. Where an implementation differs from a rule, the implementation is in error, and the difference is recorded in spec/DEFECTS.md with a program that reproduces it.

That was not always so. Every rule here began as a description of what the tree-walking interpreter in compiler/*.a24 does, verified by running it rather than by reading it — and most rules still are exactly that. A rule is only allowed to depart from the implementation by an explicit decision, and when it does it carries a marker:

NOT YET IMPLEMENTED. … See DEF-nn.

A rule without such a marker describes behavior that was observed. A rule with one describes behavior that was decided. The distinction is what keeps the document trustworthy, and it is why the markers are in the normative text rather than in an annex.

The specification does not hedge. Where a behavior is kept despite looking wrong, it is stated flatly. A specification that argues with itself cannot be conformed to.

1.2 Conformance

An implementation conforms if, for every program, it produces the output and the exit status this document requires. Diagnostics are part of that surface: their wording is specified, because it is what a user sees and what one implementation can be compared against another by.

Where a rule is marked compile-only or interpret-only, it constrains that processor alone.

1.3 How to read a rule

Every normative statement carries an immutable identifier and its evidence:

[SRC-000] An example rule, stating one thing that a single test can prove or disprove.

Identifiers are permanent. They are assigned once, never reused and never renumbered; sections may be renamed and reordered freely. Numbering the sections instead would mean that inserting one clause silently rots every citation to everything after it.

The trailer is machine-readable and spec/spec.sh checks every line of it. The four keys do different jobs, and two of them are easy to confuse:

unit is not conformance evidence, and the distinction is not pedantic. A unit test reaches into algc's own classes — it constructs a Scanner and asserts token types — so it tests the implementation, not the language. It is still worth citing, because [1.1] makes the interpreter normative and a test pinning the interpreter's behavior therefore pins the language's. But another implementation has no Scanner class to test, so a unit test can never be run against it. Only a conformance program can.

Every rule is claimed by a case, cited as conformance, refusal or defect. Which of the three is decided by one question — is the interpreter right? — and conformance/README.md explains it. Where no case existed the value was the literal TBD, so the gap was stated rather than left to be discovered; that backlog is now empty, and spec.sh still requires the line so a new rule cannot be added without one.

A rule may cite more than one, and most cases pin more than one rule. A partly implemented rule cites a conformance program for the half that works and a defect for the half that does not, so the per-kind counts overlap and do not sum to the total. spec.sh --coverage reports them separately.

unit is cited where a test happens to pin the rule and omitted where none does. It is deliberately not mandatory: a unit test is a test of algc, and there is no intention that every rule of the language should have one. The coverage report names the rules that lack one.

Non-normative material — annexes, notes, and anything under a heading marked (non-normative) — carries no identifiers and constrains nothing.

2. Notation

The syntax is given in Extended Backus-Naur Form, following the Go specification's conventions:

Production  = production_name "=" [ Expression ] "." .
Expression  = Term { "|" Term } .
Term        = Factor { Factor } .
Factor      = production_name | token [ "…" token ] | Group | Option | Repetition .
Group       = "(" Expression ")" .
Option      = "[" Expression "]" .
Repetition  = "{" Expression "}" .

Lowercase production names denote lexical tokens; uppercase names denote non-terminals. Tokens are enclosed in double quotes.

The form a … b means the set of characters from a through b inclusive. The symbol ∅ marks an empty alternative.

A quoted token in this document is matched case-insensitively if it is a keyword and exactly otherwise. See [SRC-010].

3. Source code representation

3.1 Characters

[SRC-001] Source text is UTF-8. A character, not a byte, is the unit of measurement and of subscripting.

A String carries its own byte length beside its pointer, so it may hold a zero character. It is NUL-terminated as well, which keeps as_text cheap for everything that builds a diagnostic; only the value-semantic operations — concat, output, equality, hashing, Copy, Pos, Length, subscript — consult the length.

conformance/0128-text-is-characters.a24

var S := 'café';

WriteLn (Length (S));
WriteLn (S[3]);
WriteLn (Copy (S, 1, 3));
WriteLn (Pos (S, 'é'));
WriteLn (Ord (S[3]));

// A Char is a Unicode code point, and Char and Ord are inverses across the
// whole range [LEX-025].
WriteLn (Char (233));
WriteLn (Ord (Char (233)) = 233);
WriteLn (Length (Str (Char (233))));

// A one-character literal is a Char however many BYTES it takes [LEX-023].
WriteLn ('é' is Char);

// ANY Unicode character may appear in an identifier [SRC-005], and the
// scanner admits every byte above 127 without classifying it [SRC-002].
var café := 3;
WriteLn (café);

// Any script, and no category test -- there is nothing above U+007F that is
// excluded, so the language needs no Unicode tables.
var 日本 := 4;
var Ωμέγα := 5;
WriteLn (日本 + Ωμέγα);

// Including an emoji, which may also LEAD a name -- only a digit and the
// marks '?' and '!' may not [LEX-007].
var 🙂 := 'happy';
var 💩 := 'oops';
WriteLn (🙂 + ' ' + 💩);

// A Unicode DIGIT is an ordinary identifier character too.  Only ASCII 0-9 are
// digits to the number scanner, so this can never start a numeric literal.
var ٠x := 6;
WriteLn (٠x);

// Folding is ASCII-only [SRC-011], so these are two names, not one.
var Straße := 'ok';
WriteLn (Straße);

Shell

$ algc conformance/0128-text-is-characters.a24
4
é
afé
3
233
é
true
1
true
3
9
happy oops
6
ok

conformance/0131-a-string-holds-a-zero-character.a24

var S := 'a' + Str (Char (0)) + 'b';

WriteLn (Length (S));
WriteLn (Ord (S[1]));

// Equality compares the bytes it has, rather than stopping at the zero.
WriteLn (S = 'a' + Str (Char (0)) + 'b');
WriteLn (Copy (S, 1, 2) = Str (Char (0)) + 'b');

// And so does the hash, or a Map would not find a key it holds.
var M := [S : 'held'];
WriteLn (M.Contains ('a' + Str (Char (0)) + 'b'));

// Characters are still characters [SRC-004].
WriteLn (Length ('café'));

Shell

$ algc conformance/0131-a-string-holds-a-zero-character.a24
3
0
true
true
true
4

[SRC-002] Outside comments, string literals and character literals, every character must be one the scanner recognizes — a letter [SRC-005], a digit, or an operator or item of punctuation [LEX-012]. Any other is an error reading [line N] Error: Unexpected character: C.

The scanner used to refuse every non-ASCII byte outright, so no Unicode character could appear in a program at all outside a comment or a literal.

refusals/0001-unexpected-character.a24

// '$' is not a character the scanner recognizes.
var A := 1;
$

Shell

$ algc refusals/0001-unexpected-character.a24
Uncaught: [line 3] Error: Unexpected character: $
exit: 70

[SRC-003] Inside a comment, a string literal or a character literal, any byte is permitted and is carried through unchanged. A program may therefore hold text in any encoding, and the language will neither interpret nor validate it.

conformance/0001-source-is-utf8-text.a24

// Any byte is permitted inside a comment or a literal: café, naïve, 日本語.
WriteLn ('café');
WriteLn ('日本語');

Shell

$ algc conformance/0001-source-is-utf8-text.a24
café
日本語

[SRC-004] Length of a String is its count of characters, and subscripting a String yields the character at that position. Length('café') is 4, and 'café'[3] is é.

The same holds for every operation that counts or indexes text — Copy, Pos, and Ord [16.2].

Counting characters came out faster than counting bytes, which is not the direction it looks. Subscripting text used to call strlen on the whole string for every character, so the scanner walked its entire source once per character read — quadratic, and nothing had noticed. Caching a string's character count by pointer removed that: measured over three runs of ./test.sh, 20.1 s against 21.2 s before.

[SRC-002] and [SRC-003] together mean an identifier is ASCII while a string is not. The restriction is on the program text the scanner reads, not on the data a program may carry.

3.2 Letters and digits

[SRC-005] The following classes are used by the grammar:

letter          = "a" … "z" | "A" … "Z" | "_" | unicode_character .
decimal_digit   = "0" … "9" .
hex_digit       = decimal_digit | "a" … "f" | "A" … "F" .
binary_digit    = "0" | "1" .
identifier_mark = "?" | "!" .

unicode_character is any character above U+007F, whatever Unicode classifies it as. café, Straße, 日本, 🙂 and 💩 are all identifiers.

There is no category test, and that is deliberate. Nothing above U+007F is excluded, so the language needs no Unicode tables at all — Annex G.3's mangling escapes whatever C cannot spell as U followed by six hexadecimal digits, and there is nothing left for a classification to decide.

This briefly read unicode_letter literally, and the implementation grew a 659-range table of categories Lu, Ll, Lt, Lm and Lo to match. That excluded 🙂 and 💩, which are identifiers here, and the table answered a question the language does not ask. Both were removed.

A Unicode digit is therefore an ordinary identifier character. Only ASCII 0–9 are digits to the number scanner, so ٠ cannot start a numeric literal, but it may appear in a name.

decimal_digit and identifier_mark are still ASCII, and a digit or a mark may not lead [LEX-007]. A character above U+007F may.

conformance/0002-letters-and-digits.a24

var Gate? := 1;
var _under := 2;
var a1b2 := 3;
WriteLn (Gate? + _under + a1b2);

Shell

$ algc conformance/0002-letters-and-digits.a24
6

conformance/0139-unicode-identifiers.a24

var café  := 1;
var Straße := 2;
var 日本   := 4;
var Ωμέγα := 8;
WriteLn (café + Straße + 日本 + Ωμέγα);

// An emoji may LEAD a name; only a digit and the marks may not [LEX-007].
var 🙂 := 'happy';
var 💩 := 'oops';
WriteLn (🙂 + ' ' + 💩);

// A Unicode DIGIT is an ordinary identifier character.  Only ASCII 0-9 are
// digits to the number scanner, so this can never start a numeric literal.
var ٠x := 16;
WriteLn (٠x);

// The marks, which are ASCII and trail only.
var Gate?  := 32;
var Gate!  := 64;
var Ready_Set := 128;
WriteLn (Gate? + Gate! + Ready_Set);

// TWO NAMES THAT MUST NOT COLLIDE, which is why these two.  A mangling that
// wrote '?' as '_q' and passed letters through untouched would emit ONE symbol
// for both, and cc would refuse the result.  Escaping is injective: they are
// 'readyQ' and 'readyVq'.
var Ready?  := 'from the mark';
var Ready_q := 'from the letters';
WriteLn (Ready? + ' / ' + Ready_q);

// And the collision the NEW scheme has to avoid in turn: an identifier
// spelled like an escape.  Lowercasing is what separates them -- 'u01f642'
// against 'U01F642' -- which is why case-insensitivity [SRC-011] and the escape
// space depend on each other.
var U01F642 := 'spelled out';
WriteLn (U01F642 + ' / ' + 🙂);

// Folding is ASCII-only [SRC-011], so these stay two names.
var STRASSE := 256;
WriteLn (Straße + STRASSE);

Shell

$ algc conformance/0139-unicode-identifiers.a24
15
happy oops
16
224
from the mark / from the letters
spelled out / happy
258

An identifier mark is not a letter. ? and ! may appear within an identifier but may not begin one [LEX-007], so Gate? and Gate! are each a single word — one word to the scanner, and one word to double-click — while ? and ! alone are not identifiers at all. _ is a letter and may lead.

Neither mark is an operator. The language spells negation not and inequality <>, so nothing else wants the characters.

3.3 Line termination

[SRC-006] A line ends at #10. A #13 immediately preceding it is part of the terminator and is absorbed with it, so a file with CRLF endings and the same file with LF endings report identical line numbers.

The two cases below are a pair, and neither proves the rule alone: they are the same program with different line endings, and the rule is that they report identically.

conformance/0006-line-endings-lf.a24

var A := 1;
var B := 2;
$

Shell

$ algc conformance/0006-line-endings-lf.a24
Uncaught: [line 3] Error: Unexpected character: $
exit: 70

conformance/0006-line-endings-crlf.a24

var A := 1;
var B := 2;
$

Shell

$ algc conformance/0006-line-endings-crlf.a24
Uncaught: [line 3] Error: Unexpected character: $
exit: 70

[SRC-007] Any other #13 is not a terminator. In source it is whitespace [SRC-008]; in data it is ordinary text that ReadLn returns [RT-016].

A file whose only line endings are #13 therefore holds one line, in source and in data alike. Every diagnostic in such a source file reports line 1.

A sharper consequence, from this rule meeting [LEX-001]: a comment runs to #10 or to end of file, so a // comment in a file with no #10 anywhere swallows the rest of the file. A CR-only source beginning with a comment is therefore an empty program that runs and does nothing, rather than one that fails to compile.

This follows from having a single rule rather than three, and it is the reason for having one: #10 terminates everywhere, #13#10 counts once, and a stray #13 is never a terminator in either subsystem. Admitting a lone #13 as a third convention would buy compatibility with a format no live system produces, at the cost of changing how ReadLn splits data — so a program reading text with embedded #13 bytes that are not line endings would start dividing it differently.

conformance/0007-carriage-return-only.a24

Shell

$ algc conformance/0007-carriage-return-only.a24

conformance/0009-comment-swallows-a-cr-only-file.a24

Shell

$ algc conformance/0009-comment-swallows-a-cr-only-file.a24

A file with CRLF endings and the same file with LF endings report identical line numbers. A lone #13 between two statements separates them as any other whitespace would. Verified.

[SRC-008] Whitespace is the space, #9 and #13. It separates tokens and is otherwise insignificant.

conformance/0003-line-termination.a24

// #10 ends a line; space and #9 separate tokens and mean nothing else.
var	A	:=	1;
var   B   :=   2;
WriteLn (A + B);

Shell

$ algc conformance/0003-line-termination.a24
3

[SRC-009] The final line of a file need not be terminated.

conformance/0004-final-line-need-not-be-terminated.a24

WriteLn ('first');
WriteLn ('last, with no terminator after it');

Shell

$ algc conformance/0004-final-line-need-not-be-terminated.a24
first
last, with no terminator after it

3.4 Case

[SRC-010] Keywords are matched case-insensitively. begin, Begin and BEGIN are the same keyword.

conformance/0005-keywords-are-case-insensitive.a24

BEGIN
    WriteLn ('upper');
END
Begin
    WriteLn ('mixed');
End
begin
    WriteLn ('lower');
end

Shell

$ algc conformance/0005-keywords-are-case-insensitive.a24
upper
mixed
lower

[SRC-011] Identifiers are matched case-insensitively, as keywords are. Xyz and xyz are one name, and declaring both in one scope is a duplicate [VAR-007].

Folding is ASCII-only. Straße and STRASSE are different names.

This is a decision, not a gap. Admitting Unicode case folding would be a change to this rule in its own right, and it is not implied by [SRC-005] admitting every character above U+007F as a letter — that rule needs no tables precisely because it classifies nothing. Full folding maps ß to ss, which would make those two one name — a different language from the one signed off here.

Only the lookup is folded. A diagnostic quotes the lexeme as written, so a program declaring Xyz and misspelling it xyZ is told about xyZ.

Folding happens where a name becomes a key, never to the lexeme itself, through one named function so that every store folds the same way as every lookup. compiler/Token.a24's FoldCase scans for an uppercase letter before building anything, because a name that is already folded must not allocate.

Every diagnostic on the path had to be corrected. Folding the key made messages echo the key: a program writing Shared was told about shared, a unit spelled Deep was reported as deep. A message names the occurrence the program wrote.

conformance/0126-identifiers-are-case-insensitive.a24

// A variable.
var Total := 0;
TOTAL := total + 5;
WriteLn (ToTaL);

// A field and a method, including the implicit 'this' path inside a method.
class Box;
var Value : Integer;
begin
    constructor Init (V : Integer); begin this.VALUE := V; end
    function Doubled (); begin Exit value * 2; end
end

var B := Box (21);
WriteLn (B.DOUBLED ());
WriteLn (b.value);

// A function.
function Greet (Who : String); begin Exit 'hi ' + Who; end
WriteLn (GREET ('you'));

// An enumeration and its members.  The member still PRINTS as it was
// declared -- only the lookup folds.
type Colour = (Red, Green);
WriteLn (COLOUR.red);
WriteLn (GREEN);

// A built-in member folds too, and this is the half that is easy to miss:
// were 'L.add' to answer 'Undefined property' in one processor and work in the
// other, a program written against either would fail against the other.
var L := [1];
L.add (2);
WriteLn (L.LENGTH);

var S := 'hi';
WriteLn (S.Length);

Shell

$ algc conformance/0126-identifiers-are-case-insensitive.a24
5
42
21
hi you
Red
Green
2
2

refusals/0036-case-insensitive-duplicate.a24

var Xyz := 1;
var xyz := 2;

Shell

$ algc refusals/0036-case-insensitive-duplicate.a24
Uncaught: 'xyz' is already defined.
exit: 70

Folding is uniform, as Pascal's is: a name is a name whether it is a keyword, a variable, a field, a method or a type [VAL-006]. A program may not declare Count and count as two variables, and may not declare a variable named Begin [LEX-009].

A module name is the one exception, and it is not the language's to make: a module names a file, and the filesystem decides how that name is matched. See [MOD-002].

4. Lexical elements

4.1 Comments

[LEX-001] A comment begins with // and runs to the end of the line, or to the end of the file if no #10 follows. It is discarded and forms no token.

conformance/0011-comments.a24

// A comment runs to the end of the line.
WriteLn ('one');   // and may follow code on the same line
/// LEX-002: three slashes are not a distinct form.  The scanner sees '//'
/// followed by a comment whose first character is '/'.
WriteLn ('two');
//WriteLn ('never');
WriteLn ('three');

Shell

$ algc conformance/0011-comments.a24
one
two
three

[LEX-002] /// is not a distinct form. The scanner sees // followed by a comment whose first character is /, and treats it as any other comment.

The project writes documentation comments as /// by convention, and tools may treat them specially. The language does not.

[LEX-003] There are no block comments and no nesting. { … } and (* … *) are not comments. The braces are refused as unexpected characters [SRC-002]; the parenthesis form scans as a ( followed by a *, which is not a prefix operator, and fails with Expect expression!.

refusals/0002-block-comment-braces.a24

{ this is not a comment }
WriteLn ('never reached');

Shell

$ algc refusals/0002-block-comment-braces.a24
Uncaught: [line 1] Error: Unexpected character: }
exit: 70

4.2 Tokens

[LEX-004] A token is an identifier, a keyword, a literal, or an operator or item of punctuation. Whitespace and comments separate tokens and are otherwise discarded.

conformance/0017-tokens-and-separation.a24

// Whitespace and comments SEPARATE tokens and are otherwise discarded, so the
// same expression written densely and written spaciously is one token stream.
var Dense := 1+2*3;
var Loose :=   1    // a comment between two tokens
    +
    2  *  3 ;

WriteLn (Dense);
WriteLn (Loose);
WriteLn (Dense = Loose);

Shell

$ algc conformance/0017-tokens-and-separation.a24
7
7
true

[LEX-005] Where a shorter and a longer token both match, the longer is taken. < followed by > is one <>; < followed by anything else is a < on its own.

conformance/0012-operators.a24

// LEX-012: the operators and punctuation.
WriteLn (5 + 3);
WriteLn (5 - 3);
WriteLn (5 * 3);
WriteLn (15 / 3);

// LEX-013: '=' compares, ':=' assigns, '<>' is inequality.  There is no '=='.
var A := 5;
WriteLn (A = 5);
WriteLn (A <> 5);

// LEX-005: the longer token wins.  '<=' is one token, and '<' followed by
// something that is not '>' or '=' is a '<' on its own.
WriteLn (3 <= 3);
WriteLn (3 <  4);
WriteLn (3 >= 3);
WriteLn (3 >  2);

// LEX-014: the word operators.  'div' and 'mod' are among them, because '/'
// is real division [EXP-004] and they are how the Integer pair is asked for.
WriteLn (15 div 4);
WriteLn (15 mod 4);
WriteLn (True and True);
WriteLn (True or False);
WriteLn (not False);
WriteLn (5 is Integer);
WriteLn ('a' in ['a', 'b']);

Shell

$ algc conformance/0012-operators.a24
8
2
15
5.0
true
false
true
true
true
true
3
3
true
true
true
true
true

<<><=< scans as <, <>, <=, < — four tokens.

[LEX-006] There is no automatic semicolon insertion. A line ending is whitespace and never stands in for a ;.

refusals/0004-no-semicolon-insertion.a24

WriteLn (1)
WriteLn (2)

Shell

$ algc refusals/0004-no-semicolon-insertion.a24
Uncaught: Expect ';' after expression.
[ERROR] refusals/0004-no-semicolon-insertion.a24: Expect ';' after expression.
[ERROR] 1 | WriteLn (1)
[ERROR]   |           ^
exit: 70

4.3 Identifiers

[LEX-007] An identifier is a letter followed by any number of letters, digits and identifier marks. letter, decimal_digit and identifier_mark are as defined in [SRC-005].

identifier = letter { letter | decimal_digit | identifier_mark } .

Gate?, Send!, _under and a1b2 are identifiers. Ready?Set is one identifier too: a mark does not end a word.

conformance/0010-identifier-forms.a24

// A letter, then letters, digits and identifier marks in any mixture.  Both
// marks are ordinary identifier characters, so these are four names.
var Gate?  := 1;
var Send!  := 2;
var _under := 4;
var a1b2   := 8;

// A mark does not end a word: Ready?Set is ONE identifier, not three tokens.
var Ready?Set := 16;

WriteLn (Gate? + Send! + _under + a1b2 + Ready?Set);

Shell

$ algc conformance/0010-identifier-forms.a24
31

conformance/0120-identifier-marks.a24

var Gate?     := 1;
var Send!     := 2;
var _under    := 4;
var a1b2      := 8;
var Ready?Set := 16;

WriteLn (Gate? + Send! + _under + a1b2 + Ready?Set);

// A mark does not end a word, and either may appear more than once.
var Both?!    := 32;
WriteLn (Both?!);

Shell

$ algc conformance/0120-identifier-marks.a24
31
32

[LEX-008] An identifier mark may not begin an identifier. ? and ! alone are not identifiers, and neither are ?abc and !abc: the mark is refused as an unexpected character [SRC-002], because nothing else in the language claims it.

refusals/0032-a-mark-may-not-begin-an-identifier.a24

var ? := 7;

Shell

$ algc refusals/0032-a-mark-may-not-begin-an-identifier.a24
Uncaught: [line 1] Error: Unexpected character: ?
exit: 70

The rule exists so that Gate? can be one word without ? also becoming a name. A trailing mark reads as punctuation on a word; a leading one reads as an operator the language does not have.

[LEX-009] An identifier may not be spelled the same as a keyword in any case, because the keyword is recognized first. var begin := 7; and var BEGIN := 7; are both refused with Expect variable name.

refusals/0003-keyword-is-not-a-name.a24

var begin := 7;

Shell

$ algc refusals/0003-keyword-is-not-a-name.a24
Uncaught: Expect variable name.
[ERROR] refusals/0003-keyword-is-not-a-name.a24: Expect variable name.
[ERROR] 1 | var begin := 7;
[ERROR]   | ^^^
exit: 70

4.4 Keywords

[LEX-010] The following 44 words are keywords and are matched case-insensitively per [SRC-010]:

and     as       begin   break     case    class    const   constructor
continue         div     do        else    end      except  exit
external         false   for       function         goto    if
in      is       mod     nil       not     object   of      operator
or      private  procedure         property         public  raise
super   then     this    true      try     type     uses
var     while

No other word is a keyword. Every word not in this list is an identifier and may be declared as a name.

print used to be registered in this list, introducing a statement [STM-022]. Neither was part of the language, and var print := 7; was refused with Expect variable name.

conformance/0133-print-is-an-ordinary-name.a24

var print := 7;
WriteLn (print);

print := print + 1;
WriteLn (print);

class Printer;
var print : Integer;
begin
end

var P := Printer ();
P.print := 3;
WriteLn (P.print);

function Emit (print : String);
begin
    Exit 'got ' + print;
end

WriteLn (Emit ('it'));

Shell

$ algc conformance/0133-print-is-an-ordinary-name.a24
7
8
3
got it

[LEX-011] unit, test and on are not keywords. They are ordinary identifiers that the grammar recognizes by position — unit opening a file, test before a block's quoted name, on introducing a handler — and each may be used as a variable name.

conformance/0018-context-sensitive-words.a24

// 'unit', 'test' and 'on' are not keywords.  The grammar recognizes them by
// position, and each may be used as an ordinary name.
var unit := 1;
var test := 2;
var on   := 4;

WriteLn (unit + test + on);

Shell

$ algc conformance/0018-context-sensitive-words.a24
7

var test := 7; is a valid declaration, and so are the unit and on forms. Verified in all three.

4.5 Operators and punctuation

[LEX-012] The following are operators and punctuation:

(    )    [    ]    ,    .    ;    :
+    -    *    /    =    :=
<    <=   >    >=   <>

[LEX-013] = is equality and := is assignment. Inequality is <>. There is no ==, no != and no ! operator: negation is not, and ! is an identifier mark [SRC-005] rather than punctuation.

Because ! never begins a token [LEX-008], A!=B is unambiguous: it is the identifier A! compared with B. There is no != for it to be mistaken for.

[LEX-014] and, or, not, in, is, as, div and mod are operators spelled as keywords rather than punctuation, and are subject to [SRC-010].

div and mod are words for the reason the logical operators are: they are operations, not punctuation, and Pascal has always spelled them so. It is also what leaves / free to mean one thing — real division [EXP-004] — instead of two.

{ and } are not tokens of the language at all — not as comment delimiters, not as block delimiters, and not as set constructors. A block is begin … end; a collection literal uses [ and ].

4.6 Integer literals

[LEX-015] An integer literal is a run of digits in one of three bases, with an optional separator between digits.

integer_lit = decimal_lit | hex_lit | binary_lit .

decimal_lit = decimal_digit { [ "_" ] decimal_digit } .
hex_lit     = "0x" hex_digit { [ "_" ] hex_digit } .
binary_lit  = "0b" binary_digit { [ "_" ] binary_digit } .

The base prefix and the hexadecimal digits are matched without regard to case, as every other name in the language is [SRC-011]: 0XFF, 0xff and 0xFF are one literal.

conformance/0013-integer-literals.a24

// LEX-015: a run of decimal digits.
WriteLn (42);

// LEX-017: leading zeros are permitted and carry no meaning -- 007 is seven,
// not an octal.
WriteLn (007);

// LEX-019: there is no negative literal.  A leading '-' is the unary operator,
// which is why '2-1' is a subtraction rather than two adjacent expressions.
WriteLn (-5);
WriteLn (2-1);

// A literal has no upper bound, because an Integer has none [LEX-018].  These
// are ordinary runs of digits, not values near a limit.
WriteLn (2147483647);
WriteLn (1234567890);

// A leading '-' is the operator here too, so this is unary minus over one
// positive literal and a subtraction of another.
WriteLn (-2147483647 - 1);

Shell

$ algc conformance/0013-integer-literals.a24
42
7
-5
1
2147483647
1234567890
-2147483648

[LEX-016] There are three bases — decimal, hexadecimal 0x and binary 0b — and a digit separator _. A separator separates two digits and carries no other meaning: it may not lead, trail, or stand beside anything but a digit.

There is no octal. It is a PDP-11 artefact, and 0755 silently meaning 493 is a classic defect; C# omits it for the same reason. Three bases where two are used is a name the reader must know for nothing.

A comma separator is impossible rather than merely awkward. F (1,000,000) is already a call with three arguments and [1,000,000] a list of three elements — both valid, with a different meaning. No lookahead resolves it, because both readings are complete. _ is the only separator available to a language with comma-separated arguments and collection literals.

0x and 0b rather than Turbo Pascal's $FF. $ is unclaimed, and $FF would sit consistently beside #10, which the language already has for a code point. But Turbo Pascal has no binary form at all, so $FF beside 0b1010 would mix two traditions in one sentence. The choice is for coherence with the binary form, not for modernity.

A separator does not survive into the value, so 1_000 and 1000 are the same literal and print alike.

conformance/0006-integer-bases-and-separators.a24

WriteLn (0xFF);
WriteLn (0b1010);
WriteLn (1_000_000);

// The prefix and the hexadecimal digits fold [SRC-011], as every other name
// in the language does.
WriteLn (0xff = 0XFF);
WriteLn (0B1010 = 0b1010);

// A separator may stand between any two digits, in any base.
WriteLn (0xFF_FF);
WriteLn (0b1010_1010);
WriteLn (1_0_0);

WriteLn (1_000 = 1000);
WriteLn (0x10 = 16);
WriteLn (0b1010 is Integer);

// '0x' is a prefix only when a digit of that base follows it.  A variable
// named 'x' after a zero is still two things.
var x := 5;
WriteLn (0 + x);

Shell

$ algc conformance/0006-integer-bases-and-separators.a24
255
10
1000000
true
true
65535
170
100
true
true
true
5

refusals/0151-a-separator-must-separate-digits.a24

WriteLn (100_);

Shell

$ algc refusals/0151-a-separator-must-separate-digits.a24
Uncaught: Expect ')' after arguments.
[ERROR] refusals/0151-a-separator-must-separate-digits.a24: Expect ')' after arguments.
[ERROR] 1 | WriteLn (100_);
[ERROR]   |          ^^^
exit: 70

[LEX-017] Leading zeros are permitted and carry no meaning. 007 is the integer 7, not an octal.

[LEX-018] An Integer is unbounded. Arithmetic never overflows: a result too large for the machine's width grows to hold it.

This is the whole of the type. "An Integer is an integer" is a sentence a reader needs nothing else to understand, where "an Integer is a signed 32-bit value, and an operation whose result falls outside that range raises" asks them to carry a boundary. Removing the boundary removes a category of error rather than diagnosing it.

Cheaper than it sounds, and the reason is worth stating. The wide path begins past 2⁶³ and almost nothing reaches it — algc cannot, since its own scanner accumulates digits through this very arithmetic. What an ordinary program pays is one predicted branch per operation, which is exactly what the range check it replaced already cost.

It used to wrap silently, so 2147483647 + 1 was -2147483648; then it raised [was LEX-018 as first written]; now it grows. Each step removed a way for a program to be surprised, and the last one removes the surprise itself.

One implementation, not two. The interpreter's + is the runtime's — Exit Left + Right in VisitBinary compiles to alg_add — so the two cannot disagree, and this landed in bootstrap/algol.c alone.

Signed overflow in C is undefined behavior, not a wrap, which is a different problem and was already avoided: the arithmetic goes through __builtin_*_overflow. What changed is only what happens on the overflow they report — the same branch that raised now promotes.

The switch that turned the check off is gone. -DALG_NO_OVERFLOW_CHECK skipped a range check and left the defined wrap that preceded it: a build that did not conform but did compute something. The same branch now decides whether to promote, so skipping it would not be a faster conforming build — it would be wrong answers. A check that may be turned off and a promotion that may not are one line of C and a different bargain.

Crossing into a machine width is a separate question, and one place answers it. A subscript, a Buffer offset, a code point and an exit status all need a number C can hold, so each asks for one and gets a diagnostic naming the value rather than a truncation.

conformance/0041-integers-grow.a24

WriteLn (2147483647 + 1);
WriteLn (9223372036854775807 + 1);
WriteLn (9223372036854775807 * 9223372036854775807);

// It DEMOTES.  A result that fits is an ordinary Integer again, so one value
// never has two representations and '=' , hashing and Map keys agree.
var Huge := 9223372036854775807 * 9223372036854775807;

WriteLn (Huge div 9223372036854775807 = 9223372036854775807);
WriteLn ((9223372036854775807 + 1) - 1 = 9223372036854775807);
WriteLn (Huge div Huge);
WriteLn (Huge div Huge is Integer);

// Factorials are the ordinary reason to want this.
function Fact (N);
begin
    var R := 1;
    for var I := 1; I <= N; I := I + 1 do R := R * I;
    Exit R;
end

WriteLn (Fact (25));
WriteLn (Fact (30) div Fact (29));

// There is still no negative literal [LEX-019], so a large negative value is
// the unary operator applied to a large positive one -- which now works.
WriteLn (-9223372036854775808);
WriteLn (0 - Huge < 0);

// 'div' truncates toward zero, both signs [EXP-018], and 'mod' takes the sign
// of the dividend [EXP-021].  '/' is real division and would lose the exactness
// this case is about.
WriteLn (Huge div 1000000000000000000000);
WriteLn ((0 - Huge) div 1000000000000000000000);
WriteLn (Huge mod 1000000000000000000000);
WriteLn ((0 - Huge) mod 1000000000000000000000);

// It is an Integer, by every question the language can ask.
WriteLn (Huge is Integer);
WriteLn (Val (Str (Huge)) = Huge);

Shell

$ algc conformance/0041-integers-grow.a24
2147483648
9223372036854775808
85070591730234615847396907784232501249
true
true
1
true
15511210043330985984000000
30
-9223372036854775808
true
85070591730234615
-85070591730234615
847396907784232501249
-847396907784232501249
true
true

conformance/0136-integer-range.a24

WriteLn (2147483646 + 1);
WriteLn (-2147483647 - 1);
WriteLn (46340 * 46340);
WriteLn (2147483647 div 1);
WriteLn (-(-2147483647));

// This was once the ONLY way to write the most negative 32-bit Integer,
// because a literal could not exceed 2147483647 and there is no negative
// literal [LEX-019].  It is now an ordinary subtraction of two ordinary
// numbers, and '-2147483648' is writable directly.
WriteLn (-2147483647 - 1);
WriteLn (-2147483648);

// A Double is NOT unbounded, and that asymmetry is deliberate: it follows
// IEEE 754, so 1 / 0 is Infinity [EXP-006] rather than an error, and a mixed
// expression is Double arithmetic.  'div' by zero is the fault [EXP-018].
WriteLn (1.0 / 0 > 0);
WriteLn (2147483647 + 1.0);

Shell

$ algc conformance/0136-integer-range.a24
2147483647
-2147483648
2147395600
2147483647
2147483647
-2147483648
-2147483648
true
2.147483648E9

[LEX-019] There is no negative literal. A leading - is the unary operator applied to a non-negative literal, which is why 2-1 is a subtraction rather than two adjacent expressions.

4.7 Double literals

[LEX-020] A double literal requires at least one digit on both sides of the point, or an exponent [LEX-022] in place of the point.

double_lit = decimal_lit "." decimal_lit [ exponent ] | decimal_lit exponent .

conformance/0014-double-literals.a24

// A double literal needs at least one digit on BOTH sides of the point.
WriteLn (1.5);
WriteLn (1.0);
WriteLn (0.25);

Shell

$ algc conformance/0014-double-literals.a24
1.5
1.0
0.25

[LEX-021] 1. is therefore not a double. It is the integer 1 followed by the . operator, and a program containing it fails with Expect property name after '.'. Likewise .5 is not a literal at all.

refusals/0005-trailing-dot-is-not-a-double.a24

WriteLn (1.);

Shell

$ algc refusals/0005-trailing-dot-is-not-a-double.a24
Uncaught: Expect property name after '.'.
[ERROR] refusals/0005-trailing-dot-is-not-a-double.a24: Expect property name after '.'.
[ERROR] 1 | WriteLn (1.);
[ERROR]   |           ^
exit: 70

[LEX-022] A literal may carry an exponent, and one that does is a Double whether or not it has a point.

exponent = ( "e" | "E" ) [ "+" | "-" ] decimal_digit { [ "_" ] decimal_digit } .

1e5 is 100000.0, 1.5e-3 is 0.0015, and 1E300 is a Double.

The exponent decides the type, which is why 1e5 is a Double rather than an Integer of the same value. A form written to say "this is a magnitude" should not answer with the type that cannot express most magnitudes.

This closed a place where the language printed a form it could not read. Str renders a large Double in exponent notation — 1.0E300 — and that text was not a literal. Nothing was unreachable, because Val parsed the exponent form and Val(Str(X)) round-tripped; but a value could not be written into a program the way the program wrote it out.

The sign belongs to the exponent, not to the literal. [LEX-019] still holds: there is no negative literal, and -1e5 is the unary operator applied to one. The - inside 1e-5 is part of the exponent and is not that operator.

conformance/0007-exponent-notation.a24

WriteLn (1e5);
WriteLn (1e5 is Double);
WriteLn (1.5e-3);
WriteLn (2e+3);

// Either case, as every other name in the language folds [SRC-011].
WriteLn (1E5 = 1e5);

// The round trip through the source, which is the point of the rule.
var Big := 1.0E300;
WriteLn (Str (Big));
WriteLn (Val (Str (Big)) = Big);

// The sign belongs to the EXPONENT.  [LEX-019] still holds -- there is no
// negative literal -- so the '-' in front is the unary operator and the one
// inside is not.
WriteLn (-1e2);
WriteLn (1e-2);

// 'e' followed by anything but an exponent is still an identifier, so this
// is a number and a name, not a malformed literal.
var eight := 8;
WriteLn (1 + eight);

Shell

$ algc conformance/0007-exponent-notation.a24
100000.0
true
0.0015
2000.0
true
1.0E300
true
-100.0
0.01
9

4.8 Character literals

[LEX-023] A quoted literal denoting exactly one character is a Char rather than a String. 'a', 'é' and '''' are all Chars; '' is the empty String and 'ab' a String of two.

The measurement is on the VALUE, not on the source span. A doubled quote '''' is two characters of source and one character of value, and it is the value that decides — because the doubling is notation for a character, and notation must not change a type.

This was the other way round, and was wrong. Measuring the span made the same character carry two types depending on how it was spelled:

''''  is Char  →  false            #39  is Char  →  true
''''  =  #39   →  false            a character not equal to itself
Ord ('''')     →  Ord failed: ''' has no ordinal.

This was wrong twice over. The implementation measured the span, and measured it in bytes — so '''' was a String and 'é' a String of length 2. One line decided both, which is why they were corrected together.

[LEX-024] A Char may also be written # followed by decimal digits, giving the character with that code point: #65 is A, #10 is a line feed and #233 is é. A # not followed by a digit is an error reading [line N] Error: Invalid character: C.

char_lit = "'" ( source_character_other_than_quote | "''" ) "'"
         | "#" decimal_digit { decimal_digit } .

char_lit and string_lit are not distinguished by the grammar — both open with a quote — and are not meant to be. [LEX-023] decides between them by counting the characters the literal denotes.

conformance/0015-char-literals.a24

// LEX-024: '#' followed by decimal digits is the character with that code
// point.
WriteLn (#65);
WriteLn (#65 is Char);
Write   ('a');
Write   (#10);

// LEX-026: a Char and a String are never equal, however alike they look.
// Both sides of the first comparison are Chars.  Copy yields a String of
// length one, which the Char 'a' is not.
WriteLn ('a' = 'a');
WriteLn (Copy ('abc', 0, 1) = 'a');

Shell

$ algc conformance/0015-char-literals.a24
A
true
a
true
false

[LEX-025] A Char is a Unicode code point: 0 … 10FFFF, excluding the surrogate range D800 … DFFF, which encodes no character. A # literal outside that range is refused when the program is read, with the shape every other scan error has — [line N] Error: … — because that is where it is detected.

A Char is held as its UTF-8 encoding — a String of one character and possibly several bytes — and alg_char_value is the single place that encodes it, so the two processors agree by construction rather than by both being restricted to what a byte can hold.

refusals/0038-char-out-of-range.a24

WriteLn (#1114112);

Shell

$ algc refusals/0038-char-out-of-range.a24
Uncaught: [line 1] Error: Char is limited to 0..10FFFF, excluding D800..DFFF: #1114112
exit: 70

[LEX-026] A Char and a String are never equal, however alike they look. 'a' = 'a' is true because both sides are Chars; Copy('abc', 0, 1) = 'a' is false, because Copy yields a String of length one and the Char 'a' is not it.

4.9 String literals

[LEX-027] A string literal is enclosed in single quotes. A quote within it is written twice.

string_lit = "'" { source_character_other_than_quote | "''" } "'" .

conformance/0016-string-literals.a24

// LEX-027: single quotes, and a quote within is written twice.
WriteLn ('it''s');

// LEX-029: '' is the empty String -- zero characters, and there is no empty
// Char.
WriteLn (Length (''));
WriteLn ('' is String);

// LEX-028: no backslash escapes.  This is four characters and the one at
// index 1 is the backslash itself.
WriteLn (Length ('a\nb'));
WriteLn ('a\nb'[1]);

// LEX-030: a literal may span lines, and the line feed is part of the value.
WriteLn (Length ('one
two'));

Shell

$ algc conformance/0016-string-literals.a24
it's
0
true
4
\
7

[LEX-028] There are no backslash escapes. 'a\nb' is four characters, and its element at index 1 is the backslash itself. A line feed is written #10 and concatenated.

[LEX-029] '' is the empty String — zero characters, and there is no empty Char. '''' is the Char holding a quote: one character of value, however many of source [LEX-023].

'''' and #39 are therefore the same value, and equal. They are two spellings of one character.

The scanner measures the literal's value, not its source span, and that one line decides two things: 'é' is a Char rather than a String of two bytes, and a doubled quote counts once.

There is then no literal for a one-character String, and that is not a loss. var S : String := 'c'; is already a type mismatch for every character but the quote [LEX-023], so '''' being writable was an accident of the measurement rather than a way of writing anything. Once a Char widens to a String at an assignment context [VAR-004], var S : String := 'a'; is how one is written, and it works for every character alike.

conformance/0130-a-doubled-quote-is-a-char.a24

WriteLn ('''' is Char);
WriteLn (#39 is Char);
WriteLn ('''' = #39);
WriteLn (Ord (''''));

// '' is the empty String, and there is no empty Char [LEX-029].
WriteLn ('' is String);
WriteLn (Length (''));

Shell

$ algc conformance/0130-a-doubled-quote-is-a-char.a24
true
true
true
39
true
0

[LEX-030] A string literal may span lines. The line feed is part of its value and advances the line count, so 'one ⏎ two' is seven characters.

[LEX-031] A string that reaches the end of the file unclosed is an error reading [line N] Error: Unterminated string., where N is the line the string opened on.

A quote closes the string before it. A file with several stray quotes therefore reports the last unpaired one, which is the string that actually runs to the end.

conformance/0110-unterminated-string-line.a24

var A := 1;
var B := 2;

WriteLn ('oops);

var C := 3;
var D := 4;
var E := 5;
var F := 6;

Shell

$ algc conformance/0110-unterminated-string-line.a24
Uncaught: [line 4] Error: Unterminated string.
exit: 70

[LEX-032] #0 is not a Char. A code point of 0 is refused exactly as an out-of-range one is [LEX-025], when the program is read.

Only the LITERAL is refused. [LEX-025] puts a Char at 0 … 10FFFF and the built-in Char(0) stays legal — which it must, because the scanner's own end-of-input sentinel is Char(0), and a scanner that cannot name its sentinel cannot scan.

Str(Char(0)) no longer truncates: a String carries its own length [SRC-001], so Length('a' + Str(Char(0)) + 'b') is 3.

refusals/0037-nul-char-literal.a24

WriteLn (#0 is Char);

Shell

$ algc refusals/0037-nul-char-literal.a24
Uncaught: [line 1] Error: '#0' is not a Char.
exit: 70

Refusing #0 is the smaller of the two available fixes and matches the range check that already exists. The larger one — giving a String an explicit length so it can hold a zero character — is the better language, and [SRC-001] already obliges a String to carry a character count distinct from its byte length, so the two changes meet. This rule is written so that adopting the larger fix later relaxes a restriction rather than reversing a guarantee.

5. Constants and variables

5.1 Variable declarations

[VAR-001] A variable is introduced by var, with an optional declared type and an optional initializer.

VarDecl = "var" identifier [ ":" Type ] [ ":=" Expression ] ";" .
Type    = identifier [ "of" identifier ] .

conformance/0019-declaration-forms.a24

// VAR-001: a type and an initializer are each optional.
var A;
var B := 1;
var C : Integer;
var D : Integer := 2;

WriteLn (A);
WriteLn (B);
WriteLn (C);
WriteLn (D);

// VAR-008: a collection may carry an element type.
var L : List of Integer := [1, 2, 3];
WriteLn (L.Length);

// Only the List form is exercised here.  VAR-008 admits 'Map of', 'Set of'
// and 'Array of' on the same terms.

Shell

$ algc conformance/0019-declaration-forms.a24
nil
1
nil
2
3

[VAR-002] A variable declared without an initializer holds nil, whatever its declared type. There is no zero value: an uninitialized Integer is nil, not 0.

conformance/0022-no-zero-value.a24

// VAR-002: a variable declared without an initializer holds nil, whatever its
// declared type.  There is no zero value -- an uninitialized Integer is nil,
// not 0.
var N : Integer;
var S : String;
var B : Boolean;

WriteLn (N);
WriteLn (S);
WriteLn (B);
WriteLn (N = nil);

// VAR-005: nil satisfies every declared type, which is what makes the above
// consistent rather than a special case.
var Explicit : Integer := nil;
WriteLn (Explicit = nil);

Shell

$ algc conformance/0022-no-zero-value.a24
nil
nil
nil
true
true

[VAR-003] A declared type constrains the initializer and every later assignment. A violation is the error Type mismatch!

refusals/0008-declared-type-constrains.a24

WriteLn ('this line never runs');

var X : Integer := 1;
X := 'text';

Shell

$ algc refusals/0008-declared-type-constrains.a24
Uncaught: Expected Integer, found String.
[ERROR] refusals/0008-declared-type-constrains.a24: Expected Integer, found String.
[ERROR] 4 | X := 'text';
[ERROR]   | ^
exit: 70

[VAR-004] A value widens to reach a written type, and is converted at the point it arrives. There are two widening pairs:

The variable holds the wider type afterwards. A declaration never misdescribes what it holds.

A plain assignment and a field reached this last, and D := 1 used to leave D holding an Integer — a declaration describing something the variable did not hold.

conformance/0025-operators-widen.a24

// Integer widens to Double.
WriteLn (1 + 1.5);

// Char widens to String, in either position.
WriteLn ('a' + 'bc');
WriteLn ('ab' + 'c');

// And two Chars concatenate to a String of two characters rather than staying
// Chars or summing their code points.
WriteLn ('a' + 'b');
WriteLn (Length ('a' + 'b'));
WriteLn (('a' + 'b') is String);

Shell

$ algc conformance/0025-operators-widen.a24
2.5
abc
abc
ab
2
true

conformance/0140-widening-at-every-context.a24

// A declaration and a const.
var A : Double := 1;
const C : Double := 2;
WriteLn (A);
WriteLn (C);

// A plain assignment, which is the context widening reached last.
var B : Double := 0.0;
B := 1;
WriteLn (B);

// A parameter and a declared return type.
function F (X : Double) : Double; begin Exit X; end
WriteLn (F (1));

// A field, through a constructor and through an initializer.
class K;
var Field : Double;
var Seeded : Double := 3;
begin
    constructor Init (); begin this.Field := 1; end
end

var Instance := K ();
WriteLn (Instance.Field);
WriteLn (Instance.Seeded);

// And from outside the class.
Instance.Field := 4;
WriteLn (Instance.Field);

// Char widens to String at the same six contexts.
var S : String := 'a';
S := 'b';
WriteLn (S + '!');

Shell

$ algc conformance/0140-widening-at-every-context.a24
1.0
2.0
1.0
1.0
1.0
3.0
4.0
b!

[VAR-017] Widening applies wherever a value meets a written type — the six assignment contexts, and nowhere else:

var X : T := E ;          const X : T := E ;
X := E ;                  Obj.Field := E ;
Exit E ;   (against a declared return type)
F (E) ;    (against a declared parameter type)

The interpreter does not know a variable's declared type at run time, and this is how the last two contexts are reached anyway. Env stores values, not types, so a plain X := 1 has nothing to consult — a declaration knows its own type, and a parameter and a return type are on the function. The TypeChecker writes the declared type onto the assignment node, having already computed it to check the assignment, and the interpreter widens with it. A field is the same arrangement on SetExpr.

A field written through this needs the receiver's type, and this is deliberately untyped so that a class's own code escapes the private-member check. The class name is taken for the widening lookup alone, after visibility has had its untyped receiver — typing this outright breaks that rule, which the checker's own tests catch.

Comparison is not among them and does not widen. 'a' and Copy('abc', 0, 1) remain unequal [LEX-026]. A widening converts toward a target type, and an = supplies none — it would have to invent one, and "convert when the sides differ" is the rule that makes = unpredictable.

[VAR-018] Narrowing is refused in every one of those contexts. var X : Integer := 1.5; is a mismatch: the value does not fit, and choosing how to lose the fraction is not a decision a declaration should make silently. var C : Char := 'ab'; is refused for the same reason.

refusals/0014-no-implicit-narrowing.a24

var X : Integer := 1.5;

Shell

$ algc refusals/0014-no-implicit-narrowing.a24
Uncaught: Expected Integer, found Double.
[ERROR] refusals/0014-no-implicit-narrowing.a24: Expected Integer, found Double.
[ERROR] 1 | var X : Integer := 1.5;
[ERROR]   |     ^
exit: 70

[VAR-005] nil satisfies every declared type, so var X : Integer := nil; is accepted.

[VAR-006] Any is the declared type meaning not known. A variable declared Any accepts every value.

It does not flow the other way. A value whose type is Any, or whose type could not be determined at all, does not satisfy a written type: neither var I : Integer := A; nor a later I := A; is accepted where A is Any. The conversion must be written, and as [VAL-007] is how to write it.

A type is not a suggestion once it is written. Where a program declares a type, every value reaching that variable either has the type already or is converted by an expression that says so and checks it. This is what lets a declared type be relied upon — by a reader, and by the C back end, which can only generate a machine representation for a variable whose type it may trust.

Writing no type remains entirely permissive. var A := M.Get (1); is ordinary and unremarkable; the rule bites only where a type was written down.

An assignment is now as strict as a declaration, and getting there was an inference problem rather than a rule problem. The asymmetry existed because refusing an untyped value at an assignment refused correct code, and the wrong trade would have been to punish a program for the checker's blind spot.

Three blind spots had to close first, and each was found by tightening the check and seeing what the compiler's own sources tripped on:

What was left could genuinely not be typed, and each site was given the as this rule prescribes — a member of an untyped parameter, a subscript of one. That is the rule working as intended rather than a concession to it: the conversion is written where the checker cannot see the type. How many such sites there are is not written down, because it changes whenever the sources do and nothing here would notice.

Scoping Inferred was not optional. While one helper read it a stale entry could only lose checking; once an ordinary variable's type comes from it, a leftover String from another function's C makes a correct program fail to check — the one kind of wrong answer that is not harmless. Generics was made scoped for exactly this reason and the pattern was copied.

conformance/0020-any-accepts-every-value.a24

// A variable declared Any accepts every value, and accepts a different kind of
// value later.
var X : Any := 1;
WriteLn (X);

X := 'text';
WriteLn (X);

X := [1, 2];
WriteLn (X.Length);

// Writing no type at all is permissive in the same way.  The rule in VAR-006
// bites only where a type WAS written down.
var Y := 1;
Y := 'text';
WriteLn (Y);

// The other direction -- Any into a written type -- is refused by [VAR-006],
// at a declaration and at an assignment alike.

Shell

$ algc conformance/0020-any-accepts-every-value.a24
1
text
2
text

conformance/0141-inference-carries-a-type.a24

// A variable declared WITHOUT a type carries its deduced type into later
// expressions, rather than reducing to no type at all.
var Text := 'abcdef';
var C := Copy (Text, 1, 1);
var Result : String := '';
Result := Result + C;
WriteLn (Result);

// A bare name inside a method may be a FIELD -- an implicit 'this.Field' --
// and a field's type is registered under 'Class::Field'.  Looking for it bare
// found nothing, which was the checker's largest blind spot.
class Reader;
var Source : String;
var At : Integer;
begin
    constructor Init (S : String); begin this.Source := S; this.At := 0; end

    function Next () : Char;
    var
        Ch : Char;
    begin
        Ch := Source[At];
        At := At + 1;
        Exit Ch;
    end
end

var R := Reader ('hi');
WriteLn (R.Next ());
WriteLn (R.Next ());

// A field declared on a PARENT is reached bare from a subclass's methods.
class Base;
var Tag : String := 'from the parent';
begin
    constructor Init (); begin end
end

class Derived (Base);
begin
    constructor Init (); begin end
    function Read () : String;
    var
        T : String;
    begin
        T := Tag;
        Exit T;
    end
end

WriteLn (Derived ().Read ());

// Writing no type stays permissive: an untyped variable accepts anything.
var Anything := Untyped ();
Anything := 5;
WriteLn (Anything);

function Untyped (); begin Exit 'x'; end

Shell

$ algc conformance/0141-inference-carries-a-type.a24
b
h
i
from the parent
5

refusals/0048-assignment-escapes-the-type.a24

function Untyped (); begin Exit 'xy'; end

var S : String;
S := Untyped ();

Shell

$ algc refusals/0048-assignment-escapes-the-type.a24
Uncaught: Expected String, found an untyped expression.
[ERROR] refusals/0048-assignment-escapes-the-type.a24: Expected String, found an untyped expression.
[ERROR] 4 | S := Untyped ();
[ERROR]   | ^
exit: 70

[VAR-007] A name may not be declared twice in one scope. The second is refused with 'X' is already defined.

Two subprograms of one name are not a duplicate where their signatures differ: they are overloads [FUN-013], selected between at the call. Two with the same signature are a duplicate like any other name.

refusals/0009-no-redeclaration.a24

var X := 1;
var X := 2;

Shell

$ algc refusals/0009-no-redeclaration.a24
Uncaught: 'X' is already defined.
exit: 70

[VAR-008] A collection may carry an element type, written of: var L : List of Integer := [];. Every collection type accepts one — List, Map, Set and Array.

For a Map the element type is the value type, since that is what a subscript and a Get yield [VAR-016]. A Map's keys are not constrained.

Wherever a type may be written, which is every context [TYP-002] names — a variable, a constant, a field, a parameter and a return type. The last two did not parse: Items : List of Integer was Expect ')' after parameters. and a return type stopped at the collection's name. Annex A's grammar has described both since it was written, and only the parser disagreed.

conformance/0121-element-type-on-every-collection.a24

var L : List of Integer  := [1, 2];
var M : Map of String    := [1 : 'one'];
var S : Set of Integer   := Set ();
var A : Array of Integer := Array (2);

WriteLn (L.Length);
WriteLn (M.Length);
WriteLn (S.Length);
WriteLn (A.Length);

// For a Map the element type is the VALUE type, because that is what a
// subscript and a Get yield.  A Map's keys are not constrained.
var V : String := M[1];
WriteLn (V);

// And it still flows to a read on a List.
var First : Integer := L[0];
WriteLn (First);

Shell

$ algc conformance/0121-element-type-on-every-collection.a24
2
1
0
2
one
1

conformance/0157-element-types-on-parameters.a24

function Total (Items : List of Integer) : Integer;
begin
    var Sum := 0;

    for var I in Items do Sum := Sum + I;

    Exit Sum;
end

WriteLn (Total ([1, 2, 3]));

// A return type carries one too, and it flows to reads from the call.
function Names () : List of String;
begin
    Exit ['alpha', 'beta'];
end

WriteLn (Names ().Get (1));
WriteLn (Names ().Get (1).Length);

// Every collection type accepts one [VAR-008].  For a Map it is the VALUE
// type, since that is what Get yields.
function Look (M : Map of Integer) : Integer;
begin
    Exit M.Get ('k');
end

WriteLn (Look (['k' : 5]));

function Count (S : Set of String) : Integer;
begin
    Exit S.Length;
end

WriteLn (Count (Set (['a', 'b'])));

// It is a source of types for READS and no constraint on writes [VAR-016],
// exactly as it is on a var -- so a parameter's element type is what makes the
// loop variable below an Integer rather than nothing.
function Widths (Items : List of String) : Integer;
begin
    var Total := 0;

    for var S in Items do Total := Total + S.Length;

    Exit Total;
end

WriteLn (Widths (['ab', 'cde']));

Shell

$ algc conformance/0157-element-types-on-parameters.a24
6
beta
4
5
2
5

[VAR-016] An element type is a source of types for reads and a constraint on writes. Given var L : List of Integer:

Every route in is covered, and there are five: Add, Push, Put, subscript assignment, and the collection literal at a declaration.

A check covering some of them would be worse than none, which is why the list is exhaustive rather than convenient. A fence with a gate in it invites the declared type to be trusted, and a type that is trusted in four places and not the fifth is more dangerous than one trusted nowhere.

Put constrains its SECOND argument. A Map of T declares the type of what is stored, which is what M[K] reads back; the key is not constrained.

Checked where the receiver's type is known, and nowhere else — the same bargain [CLS-017] makes for a property and [DCL-015] for private:. The element type is available only for a plain name: there is nowhere to have written the element type of an arbitrary expression, so an insertion through one is unchecked. It costs nothing at run time.

A bare List is unconstrained, as it always was. The element type does the constraining, so declaring none declares no constraint — which is why this rule is about the annotation rather than about collections.

It checks and does not convert. D.Add (2) into a List of Double is accepted because an Integer widens to a Double [VAR-004], and the element stored is the Integer 2. Widening happens where a value reaches a written type, and an element is not one.

conformance/0021-element-types-flow-to-reads.a24

var L : List of Integer := [10, 20];

// A subscript has the element type, and a loop variable takes it too.  Both
// are visible here only as the absence of a complaint: were the element type
// not flowing, neither line would type-check against Integer.
var First : Integer := L[0];
WriteLn (First);

for var X in L do
begin
    var Doubled : Integer := X * 2;
    WriteLn (Doubled);
end

// Insertion IS checked: an element that does not fit the declared type is
// refused at every route in, and a read carries the element type back out.
// [VAR-016] states the whole rule.
L.Add (30);
WriteLn (L.Length);
WriteLn (L[2]);

// A BARE 'List' is still unconstrained.  The element type is what does the
// constraining, so declaring none declares no constraint -- which is why this
// rule reads as being about the annotation rather than about collections.
var Loose : List := [1];
Loose.Add ('anything');
WriteLn (Loose);

Shell

$ algc conformance/0021-element-types-flow-to-reads.a24
10
20
40
3
30
[1, anything]

conformance/0173-element-types-on-insertion.a24

var L : List  of Integer := [1, 2];
var M : Map   of Integer := [:];
var S : Stack of Integer := Stack ();

// Correct insertions, by every route.
L.Add (3);
L[0] := 9;
M.Put ('key', 7);
S.Push (4);

WriteLn (L);
WriteLn (M);
WriteLn (S.Length);

// It CHECKS and does not CONVERT.  An Integer widens to a Double [VAR-004]
// so the insertion is accepted, and what is stored is the Integer -- widening
// happens where a value reaches a written type, and an element is not one.
var D : List of Double := [1.0];
D.Add (2);
WriteLn (D);

// 'Put' constrains its SECOND argument.  A 'Map of T' declares the type of
// what is stored, which is what 'M[K]' reads back; the key is not constrained.
M.Put ('any key at all', 1);
WriteLn (M.Length);

// nil inhabits every type [VAR-005].
L.Add (Nil);
WriteLn (L);

// A bare 'List' is unconstrained: the element type does the constraining, so
// declaring none declares no constraint.
var Loose : List := [1];
Loose.Add ('anything');
WriteLn (Loose);

// So is a receiver with no declared type -- there is nowhere to have written an
// element type, which is the same limit reading one has.
var Inferred := [1];
Inferred.Add ('anything');
WriteLn (Inferred);

Shell

$ algc conformance/0173-element-types-on-insertion.a24
[9, 2, 3]
[key:7]
1
[1.0, 2]
2
[9, 2, 3, nil]
[1, anything]
[1, anything]

refusals/0173-element-type-on-add.a24

var L : List  of Integer := [1, 2];
var M : Map   of Integer := [:];
var S : Stack of Integer := Stack ();

WriteLn ('never reached');

L.Add ('text');

Shell

$ algc refusals/0173-element-type-on-add.a24
Uncaught: Expected Integer, found String.
[ERROR] refusals/0173-element-type-on-add.a24: Expected Integer, found String.
[ERROR] 7 | L.Add ('text');
[ERROR]   |   ^^^
exit: 70

refusals/0174-element-type-on-subscript.a24

var L : List  of Integer := [1, 2];
var M : Map   of Integer := [:];
var S : Stack of Integer := Stack ();

WriteLn ('never reached');

L[0] := 'text';

Shell

$ algc refusals/0174-element-type-on-subscript.a24
Uncaught: Expected Integer, found String.
[ERROR] refusals/0174-element-type-on-subscript.a24: Expected Integer, found String.
[ERROR] 7 | L[0] := 'text';
[ERROR]   |  ^
exit: 70

refusals/0175-element-type-on-put.a24

var L : List  of Integer := [1, 2];
var M : Map   of Integer := [:];
var S : Stack of Integer := Stack ();

WriteLn ('never reached');

M.Put ('k', 'text');

Shell

$ algc refusals/0175-element-type-on-put.a24
Uncaught: Expected Integer, found String.
[ERROR] refusals/0175-element-type-on-put.a24: Expected Integer, found String.
[ERROR] 7 | M.Put ('k', 'text');
[ERROR]   |   ^^^
exit: 70

refusals/0176-element-type-on-push.a24

var L : List  of Integer := [1, 2];
var M : Map   of Integer := [:];
var S : Stack of Integer := Stack ();

WriteLn ('never reached');

S.Push ('text');

Shell

$ algc refusals/0176-element-type-on-push.a24
Uncaught: Expected Integer, found String.
[ERROR] refusals/0176-element-type-on-push.a24: Expected Integer, found String.
[ERROR] 7 | S.Push ('text');
[ERROR]   |   ^^^^
exit: 70

refusals/0177-element-type-on-literal.a24

var L : List  of Integer := [1, 2];
var M : Map   of Integer := [:];
var S : Stack of Integer := Stack ();

WriteLn ('never reached');

var Bad : List of Integer := ['text'];

Shell

$ algc refusals/0177-element-type-on-literal.a24
Uncaught: Expected Integer, found String.
[ERROR] refusals/0177-element-type-on-literal.a24: Expected Integer, found String.
[ERROR] 7 | var Bad : List of Integer := ['text'];
[ERROR]   |     ^^^
exit: 70

5.2 Sections

[VAR-009] In the header of a function, procedure, class or object, var may open a section: a run of declarations, each ending in ;, closed by the next section marker or by begin.

VarSection = "var" { identifier { "," identifier } [ ":" Type ] [ ":=" Expression ] ";" } .

conformance/0023-sections.a24

function F ();
var
    A, B : Integer;          // VAR-010: several names share one declaration
    Tail : String := 'ok';   // 'ok', not 'o' -- a one-character literal is a
const                        //    Char and would not satisfy String [LEX-023]
    K := 10;                 // VAR-015: const opens a section on the same terms

begin
    A := 1;
    B := 2;

    Exit Str (A + B + K) + Tail;
end

WriteLn (F ());

Shell

$ algc conformance/0023-sections.a24
13ok

[VAR-010] Within a section several names may share one declaration: A, B : Integer; declares both.

[VAR-011] A section is a feature of a header, not of a program body. At the top level var declares exactly one name, and a run of declarations beneath it is read as ordinary statements — var A : Integer; followed by B : String; is refused.

Labels changed how it is refused, and the diagnostic got worse. B : is now read as a label [STM-010] on the statement String;, so the line parses and fails at run time with Undefined variable 'String'. rather than at parse time with Expect ';' after expression. The rule is unchanged and the program is still refused; what is lost is that it used to be caught without being run, so a mistaken section on a path never taken is now silent. This is the price of a label needing no keyword, and it is the only place in the language where the two forms collide.

refusals/0010-no-section-at-top-level.a24

var A : Integer;
    B : String;

Shell

$ algc refusals/0010-no-section-at-top-level.a24
Uncaught: Undefined variable 'String'.
exit: 70

5.3 Constants

[VAR-012] A constant is introduced by const and must be given a value. Omitting the initializer is refused with A constant must be given a value.

ConstDecl = "const" identifier [ ":" Type ] ":=" Expression ";" .

refusals/0011-const-must-be-given-a-value.a24

const C : Integer;

Shell

$ algc refusals/0011-const-must-be-given-a-value.a24
Uncaught: A constant must be given a value.
[ERROR] refusals/0011-const-must-be-given-a-value.a24: A constant must be given a value.
[ERROR] 1 | const C : Integer;
[ERROR]   |       ^
exit: 70

[VAR-013] A constant may not be assigned to. The attempt is refused with Can't assign to constant 'C'.

refusals/0012-const-is-not-assignable.a24

const C := 1;
C := 2;

Shell

$ algc refusals/0012-const-is-not-assignable.a24
Uncaught: Can't assign to constant 'C'.
exit: 70

[VAR-014] A constant's initializer is an ordinary expression evaluated at run time, not a constant expression. const C := 1 + 2; is legal, and so is const C := V; where V is a variable — the constant takes whatever value V held at that moment.

const therefore means this binding may not be reassigned, not this value is known before the program runs.

conformance/0024-const-is-a-runtime-expression.a24

// A constant's initializer is an ordinary expression evaluated when the
// declaration runs, not a constant expression.
const Computed := 1 + 2;
WriteLn (Computed);

// And it may read a variable, so a constant's value need not be known before
// the program runs.  'const' means the BINDING may not be reassigned -- not
// that the value is known in advance.
var V := 9;
const FromVariable := V;
WriteLn (FromVariable);

// Changing V afterwards does not change the constant: it took the value V held
// at that moment.
V := 100;
WriteLn (FromVariable);

Shell

$ algc conformance/0024-const-is-a-runtime-expression.a24
3
9
9

[VAR-015] const may open a section on the same terms as var, and the two may appear together in one header.

6. Types

6.1 The kinds of type

[TYP-001] A value has exactly one of these runtime types:

Pointer is in the table but not in the corpus's list, because a program cannot make one without calling C [TYP-017] and a conformance case must run in the default build. 0026 therefore names every row but that one.

conformance/0026-the-runtime-types.a24

class Dog; begin end
type Color = (Red, Green);

// TYP-001: every runtime type answers 'is' to its own name.
WriteLn (1        is Integer);
WriteLn (1.5      is Double);
WriteLn ('ab'     is String);
WriteLn ('a'      is Char);
WriteLn (True     is Boolean);
WriteLn (Dog ()   is Dog);
WriteLn (Red      is Color);
WriteLn (List ()  is List);
WriteLn (Set ()   is Set);
WriteLn (Stack () is Stack);
WriteLn (Array(2) is Array);
WriteLn (Map ()   is Map);
WriteLn (Buffer() is Buffer);
WriteLn (TextFile() is TextFile);

// 'Any' is a declaration, never a runtime type.
WriteLn (1 is Any);

// TYP-003: a one-character value is a Char, and stays one.  Widening moves a
// Char into a String at an assignment context [VAR-017]; 'is' is not one, and
// asks what the value IS rather than what it could become.
WriteLn ('s' is String);
WriteLn ('s' is Char);

// TYP-002: the one compound form is a collection with an element type.
var L : List of Integer := [1];
WriteLn (L.Length);

Shell

$ algc conformance/0026-the-runtime-types.a24
true
true
true
true
true
true
true
true
true
true
true
true
true
true
false
false
true
1

[TYP-015] Byte, Word and Short are subranges of Integer, not types of their own. Each names a low and a high bound:

A value is never a Byte — [TYP-001] still answers Integer — so a subrange name appears only where a type is written, and the bounds are checked where the value arrives: the six assignment contexts of [VAR-017], and nowhere else.

One feature instead of several special cases. With [LEX-018] making an Integer unbounded, a width is no longer a representation to match — only a range to name. Byte is 0 .. 255 and says so.

Short is 16 bits, and Turbo Pascal's was not. TP's ShortInt was 8 bits and its Integer 16; the modern reading is the one a reader can state without looking it up, which is the test this language applies.

There is no unsigned family. Unsigned types exist to buy one more bit inside a fixed width and to say "not negative". An unbounded Integer removes the first reason, and 0 .. states the second directly rather than encoding it in a name. It also avoids C#'s corner where long + ulong has no type to answer with.

Selection ignores the bounds [FUN-013]. Two subprograms differing only in a parameter's range claim the same signature and are a duplicate — which is the argument that rule already makes about return types: a call could never tell them apart. Consulting the bounds would send Take (200) and Take (300) to different subprograms, and would let adding an overload steal calls from one that was already there.

X is Byte is nonetheless a range test, and that is not a contradiction. The principle is that a program may ask about a value; the language may not silently dispatch on one. is is the question written where the programmer wrote it.

The check lives where widening does, and that is safe for a reason. Widening converts and refuses nothing, and making it refuse on a type mismatch would break a shape real programs use: a String reaching a field declared Expr. A range check cannot fire on that shape: it applies only when the declared name is a subrange and the value is already an Integer.

conformance/0153-subranges.a24

var B : Byte := 200;

WriteLn (B);
WriteLn (B is Byte);

// It is an Integer, and stays one.  Nothing is ever 'a Byte' -- a subrange
// constrains a value where a type is written, and TYP-001 is unchanged.
WriteLn (B is Integer);
WriteLn (B + 1 is Integer);

// 'is' on a subrange is a RANGE TEST, which is the program asking
// explicitly.  What the language may not do is dispatch on a value silently.
WriteLn (0 is Byte);
WriteLn (255 is Byte);
WriteLn (256 is Byte);
WriteLn (-1 is Byte);
WriteLn (32767 is Short);
WriteLn (-32768 is Short);
WriteLn (65535 is Word);

// Only an Integer is ever within one.
WriteLn (1.5 is Byte);
WriteLn ('a' is Byte);

// The bounds are checked at the assignment contexts [VAR-017].
try
    var Bad : Byte := 300;
except
    on e : String do WriteLn (e);
end

var C : Byte := 1;
C := 250;
WriteLn (C);

try
    C := 999;
except
    on e : String do WriteLn (e);
end

procedure Pixel (R : Byte, G : Byte);
begin
    WriteLn (Str (R) + ',' + Str (G));
end

Pixel (10, 20);

try
    Pixel (10, 300);
except
    on e : String do WriteLn (e);
end

Shell

$ algc conformance/0153-subranges.a24
200
true
true
true
true
true
false
false
true
true
true
false
false
300 is not in Byte.
250
999 is not in Byte.
10,20
300 is not in Byte.

[TYP-016] A program declares a subrange of its own with type, giving a low and a high bound.

SubrangeDecl = "type" identifier "=" bound ".." bound ";" .
bound = [ "-" ] integer_lit .

type Digit   = 0 .. 9;
type Celsius = -273 .. 1000;

It behaves exactly as a predefined one [TYP-015]: an Integer for every question about type, its own name for the question about range.

The bounds are literals, not expressions. A subrange is hoisted like a class and an enumeration, so its bounds must be known before anything runs — and an expression would have to be evaluated, which needs the declaration to have run already. The restriction can be relaxed later by admitting constants, and nothing in the rule prevents it.

The sign is read by the declaration, because [LEX-019] still holds: there is no negative literal, and -273 is the unary operator applied to one. Where an expression cannot be evaluated, the same rule is applied by hand.

An empty subrange is refused where it is read. type Empty = 9 .. 0; is A subrange must not be empty: 9 is above 0. — it admits no value at all, so every assignment through it would fail and the declaration is the only place that can say why.

type declares two different things, and which is decided by the character after the =: a ( begins an enumeration [ENU-001], anything else a subrange. Both bind a name that denotes a type and neither binds a value.

conformance/0154-declared-subranges.a24

type Digit   = 0 .. 9;
type Celsius = -273 .. 1000;

var D : Digit := 7;

WriteLn (D);
WriteLn (D is Digit);

// It is an Integer, and stays one.  A subrange constrains a value where a
// type is written; nothing is ever 'a Digit' [TYP-001].
WriteLn (D is Integer);
WriteLn (D + 1 is Integer);

WriteLn (0 is Digit);
WriteLn (9 is Digit);
WriteLn (10 is Digit);
WriteLn (-1 is Digit);

// The sign is read by the DECLARATION, because there is no negative
// literal [LEX-019].
WriteLn (-273 is Celsius);
WriteLn (-274 is Celsius);
WriteLn (1000 is Celsius);

// The bounds are checked at the assignment contexts [VAR-017].
try
    var Bad : Digit := 10;
except
    on e : String do WriteLn (e);
end

procedure Show (N : Digit);
begin
    WriteLn ('digit ' + Str (N));
end

Show (3);

try
    Show (42);
except
    on e : String do WriteLn (e);
end

// A declared subrange and a predefined one are the same kind of thing.
var B : Byte := 200;
WriteLn (B is Byte);
WriteLn (B is Digit);

Shell

$ algc conformance/0154-declared-subranges.a24
7
true
true
true
true
true
false
false
true
false
true
10 is not in Digit.
digit 3
42 is not in Digit.
true
false

[TYP-014] Real is another spelling of Double. It is not a second type: X is Real and X is Double answer alike, a parameter declared either accepts the same arguments, and two subprograms differing only in which was written claim the same signature [FUN-013].

An alias, not a conversion. C# settled this shape: int is System.Int32, one type with two names and no box between them. Java's int/Integer duality — two things with almost the same name behaving differently — is the arrangement this avoids.

The canonical spelling is Double, and a diagnostic uses it: X as Real on a String is Cannot cast String to Double. The alias telling a reader what it is, is worth more than echoing what they wrote.

Turbo Pascal's Real was a 6-byte software float from before the 8087, with no C type to map onto. A type whose only distinction is a 1985 storage format is the opposite of self-explanatory, so the name survives and the representation does not. Delphi reached the same conclusion.

There is no Single. A 32-bit float earns its place in a language whose values are unboxed, by halving the storage of an array; Algol-24's values are tagged and one size, so it would cost a reader "32-bit IEEE, less precision" and buy nothing.

Replaced where a written type becomes something to compare, and nowhere else, so no part of the implementation past the front end knows the alias exists — the C runtime has no case for it at all. is is canonicalised at its two use sites rather than at the parser, because it carries a token where the others carry a string.

conformance/0152-real-is-double.a24

var X : Real := 1.5;

WriteLn (X);
WriteLn (X is Real);
WriteLn (X is Double);

// One type, so widening reaches it exactly as it reaches the other
// spelling [VAR-004].
var Y : Real := 1;
WriteLn (Y);
WriteLn (Y is Double);

// A parameter declared either way accepts the same arguments.
function Twice (R : Real); begin Exit R * 2; end

WriteLn (Twice (3));
WriteLn (Twice (2.5));

var Z : Any := 1.5;
WriteLn (Z as Real);

// The CANONICAL spelling is what a diagnostic names, which is the alias
// telling the reader what it is.
var Bad : Any := 'text';
try
    WriteLn (Bad as Real);
except
    on e : String do WriteLn (e);
end

// It folds like every other name [SRC-011].
WriteLn (1.5 is real);
WriteLn (1.5 is REAL);

Shell

$ algc conformance/0152-real-is-double.a24
1.5
true
true
1.0
true
6.0
5.0
1.5
Cannot cast String to Double.
true
true

[TYP-002] A type is written as an identifier. The only compound form is a collection type with an element type, written of — List of Integer, Map of Token [VAR-008].

Type = identifier [ "of" identifier ] .

[TYP-003] Char and String are distinct types, and a one-character value is a Char. 's' is String is false.

Widening does not change this. A Char widens to a String on its way into a written type [VAR-004], but is asks what a value is, not what it could become, and a type test is not one of the six assignment contexts [VAR-017]. A Char that has widened is a String and answers so; the Char it came from is not.

6.2 Any

[TYP-004] Any is the declared type meaning the type is not known. A variable declared Any accepts every value; a value of type Any does not satisfy a written type without a cast [VAR-006]. No value ever reports Any as its runtime type, so X is Any is false for every X [VAL-005].

refusals/0013-any-does-not-satisfy-a-written-type.a24

var A : Any := 1;
var I : Integer := A;

Shell

$ algc refusals/0013-any-does-not-satisfy-a-written-type.a24
Uncaught: Expected Integer, found Any.
[ERROR] refusals/0013-any-does-not-satisfy-a-written-type.a24: Expected Integer, found Any.
[ERROR] 2 | var I : Integer := A;
[ERROR]   |     ^
exit: 70

The asymmetry is the point of [VAR-006]: Any is where a type is not known, and a written type is a claim that it is. Moving from the first to the second is a conversion, and as is how one is written.

6.3 nil

[TYP-005] nil is of no type at all. nil is T is false for every T, including the type nil was declared as.

conformance/0027-nil-has-no-type.a24

// TYP-005: nil is of no type at all -- not even the one it was declared as,
// and not Any.
var X : Integer := nil;
WriteLn (X is Integer);
WriteLn (nil is Any);
WriteLn (X = nil);

// TYP-006: yet nil satisfies every declared type for assignment.  A value that
// is not there has no type to check.
var S : String := nil;
var D : Dog    := nil;
var L : List   := nil;
WriteLn (S);
WriteLn (D);
WriteLn (L);

class Dog; begin end

Shell

$ algc conformance/0027-nil-has-no-type.a24
false
false
true
nil
nil
nil

[TYP-006] nil nonetheless satisfies every declared type for the purpose of assignment — see [VAR-005]. A value that is not there has no type to check, and is accepted everywhere.

[TYP-013] A type name must denote a declared type. A name that denotes nothing is refused when the program is read, rather than being read as a type no value has.

The name used never to be resolved: 1 is Nonexistent was false, silently, so a misspelled type answered false and the branch it guarded never ran — while an undefined variable in the same position has always been Undefined variable 'X'.

Any stays legal, though X is Any is always false [VAL-005]. It names something; it just never matches.

Checked folded, because is folds at run time — SatisfiesType lowers both sides, so 1 is dog finds class Dog and refusing it here would refuse a program that runs.

Writing that case down found a second fault: InheritsFrom compared class names exactly while SatisfiesType folded its direct match, so Puppy() is Dog was true and Puppy() is dog was false — one operator disagreeing with itself about case, and the C runtime folding both. Fixed with this rule.

refusals/0040-unknown-type-name.a24

WriteLn (1 is Nonexistent);

Shell

$ algc refusals/0040-unknown-type-name.a24
Uncaught: Unknown type 'Nonexistent'.
[ERROR] refusals/0040-unknown-type-name.a24: Unknown type 'Nonexistent'.
[ERROR] 1 | WriteLn (1 is Nonexistent);
[ERROR]   |               ^^^^^^^^^^^
exit: 70

conformance/0135-type-names-that-denote.a24

class Dog; begin end
class Puppy (Dog); begin end
type Colour = (Red, Green);
object Reg; begin end

WriteLn (Puppy () is Dog);
WriteLn (1 is Integer);
WriteLn (1.5 is Double);
WriteLn ('ab' is String);
WriteLn ('a' is Char);
WriteLn (True is Boolean);
WriteLn (1 is Any);

WriteLn ([1] is List);
WriteLn (Set () is Set);
WriteLn (Stack () is Stack);
WriteLn (Array (1) is Array);
WriteLn ([1 : 2] is Map);
WriteLn (Buffer () is Buffer);
WriteLn (TextFile () is TextFile);

WriteLn (Red is Colour);
WriteLn (Reg is Reg);

// Matched WITHOUT REGARD TO CASE, because 'is' folds at run time [SRC-011].
// The check has to fold too, or it would refuse a program that runs.
WriteLn (Puppy () is dog);

Shell

$ algc conformance/0135-type-names-that-denote.a24
true
true
true
true
true
true
false
true
true
true
true
true
true
true
true
true
true

This is not a gradual-typing case. Gradual typing concerns a value whose type is not known, which is ordinary; a type name is written by the programmer and must denote something.

6.4 Collection types

[TYP-007] The five collection types are distinguished by their kind, and each answers is to its own name only. A List is not a Set.

conformance/0028-collection-types-are-distinct.a24

var L := List ();
WriteLn (L is List);
WriteLn (L is Set);
WriteLn (L is Stack);
WriteLn (L is Array);
WriteLn (L is Map);

var S := Set ();
WriteLn (S is Set);
WriteLn (S is List);

Shell

$ algc conformance/0028-collection-types-are-distinct.a24
true
false
false
false
false
true
false

[TYP-008] Array is fixed in size. Its elements begin as nil, it is indexed from zero, and an index outside its bounds is the runtime error Index N out of range 0..M. It does not grow on assignment.

conformance/0029-array-is-fixed.a24

var A := Array (3);

// Elements begin as nil, and it is indexed from zero.
WriteLn (A[0]);
WriteLn (A.Length);

A[2] := 'x';
WriteLn (A[2]);

// It does not grow on assignment, and an index outside its bounds raises.
A[5] := 'y';
WriteLn ('never reached');

Shell

$ algc conformance/0029-array-is-fixed.a24
Uncaught: Index 5 out of range 0..2.
nil
3
x
exit: 70

[TYP-009] A collection is not a class instance. It has no ClassName, and asking for one is the error Undefined property 'ClassName'.

conformance/0030-collections-have-no-classname.a24

class Dog; begin end
WriteLn (Dog ().ClassName);

WriteLn (List ().ClassName);

Shell

$ algc conformance/0030-collections-have-no-classname.a24
Uncaught: Undefined property 'ClassName'.
Dog
exit: 70

6.5 What a class type cannot do

These rules are normative in their own right, and together they say which built-in behavior a program cannot reproduce for a type of its own.

[TYP-010] A class instance is subscriptable when its class declares Get taking one argument: B[0] calls B.Get (0). Assignment needs Put taking two: B[0] := X calls B.Put (0, X). Without them, B[0] is the runtime error Subscript target should be an ordinal.

The fifth structural protocol, beside Contains, ToString [CLS-009], Elements [TYP-011] and Compare [VAL-014]. It needs no member name of its own: Get and Put are what the built-in collections already answer to [COL-003], so a collection written in Algol-24 reuses the names rather than being given a second set.

A property is not one of them, though it is often listed beside them. A protocol is structural — a class either happens to declare the member or it does not — while a property is announced with a keyword [CLS-017]. The difference matters when counting: there are five protocols and one declared member kind, not six of anything.

The two forms are two members of different arity, which is the one question subscripting adds that no other operator has — and the language already tells arities apart everywhere else, so nothing has to pair a getter with a setter syntactically. A class declaring only Get is readable and not assignable, which needs no separate way of saying so.

conformance/0171-a-class-that-subscripts.a24

class Row;
var
private:
    Cells : List;

begin
    constructor Init (); begin this.Cells := [10, 20, 30]; end

    function  Get (I : Integer) : Any;    begin Exit Cells[I]; end
    procedure Put (I : Integer, V : Any); begin Cells[I] := V; end

    property  Length : Integer;           begin Exit Cells.Length; end
end

var R := Row ();

WriteLn (R[0], ' ', R[1], ' ', R[2]);
WriteLn (R.Length);

R[1] := 99;
WriteLn (R[1]);

// THE TWO FORMS ARE TWO MEMBERS of different arity, so a class declaring
// only 'Get' is readable and not assignable -- which needs no separate way of
// saying so.
class ReadOnly;
var
private:
    Cells : List;

begin
    constructor Init ();              begin this.Cells := [1, 2]; end
    function Get (I : Integer) : Any; begin Exit Cells[I]; end
end

var O := ReadOnly ();
WriteLn (O[0]);

try
    O[0] := 5;
except
    on e : String do WriteLn (e);
end

// A protocol is a NAME and a shape: 'Get' of two arguments is not this one.
class WrongShape;
begin
    constructor Init (); begin end
    function Get (I : Integer, J : Integer) : Any; begin Exit 0; end
end

try
    WriteLn (WrongShape ()[0]);
except
    on e : String do WriteLn (e);
end

// And this is what the whole protocol run was for: a Stack written in
// Algol-24 that reads like the built-in it would replace -- subscripted,
// iterated, ordered, and answering Length without parentheses.
class Stack;
var
private:
    Items : List;

begin
    constructor Init ();                  begin this.Items := []; end
    procedure Push (V : Any);             begin Items.Add (V); end

    function  Get (I : Integer) : Any;    begin Exit Items[I]; end
    function  Elements () : List;         begin Exit Items; end
    property  Length  : Integer;          begin Exit Items.Length; end
    property  IsEmpty : Boolean;          begin Exit Items.Length = 0; end
end

var S := Stack ();
S.Push (10);
S.Push (20);
S.Push (30);

WriteLn (S.Length, ' ', S.IsEmpty, ' ', S[1]);

for var X in S do Write (Str (X) + ' ');
WriteLn ();

Shell

$ algc conformance/0171-a-class-that-subscripts.a24
10 20 30
3
99
1
Subscript target should be an ordinal.
Subscript target should be an ordinal.
3 false 20
10 20 30 

conformance/0031-instance-is-not-subscriptable.a24

class Box;
var Items : List;
begin
    constructor Init (); begin this.Items := [10, 20]; end
    function At (I); begin Exit this.Items[I]; end
end

var B := Box ();
WriteLn (B.At (0));

WriteLn (B[0]);

Shell

$ algc conformance/0031-instance-is-not-subscriptable.a24
Uncaught: Subscript target should be an ordinal.
10
exit: 70

[TYP-011] A class instance is iterable when its class declares an Elements method taking no arguments; for var X in B do then walks what that method returns. An instance whose class declares no such method is the runtime error Can only iterate a collection or a String.

class Bag;
var Items : List;
begin
    constructor Init (); begin this.Items := [10, 20, 30]; end
    function Elements (); begin Exit Items; end
end

for var X in Bag () do Write (X);      // 102030

The protocol is STRUCTURAL, not declared. There is nothing to inherit from and nothing to announce: a class either has the method or it does not. Str works the same way through ToString [CLS-009], in through a Contains taking one argument, ordering through Compare [VAL-014] and subscripting through Get and Put [TYP-010] — five protocols, one convention.

A protocol is a name AND a shape. Elements taking an argument does not implement this one, and such a class is simply not iterable. Neither processor checked that: the interpreter asked for the first method of the name whatever its shape, the runtime's has_method fell back to the same, and the two then failed differently — Index 0 out of range 0..-1. against No matching signature for function., neither of them the message above.

The result is walked, not re-asked. Elements may return another instance that also declares Elements, and the chain resolves — which is what stops a List whose Elements returns a List from recursing forever.

It is snapshotted like any other walk [STM-009]. The method answers a whole collection, so the loop has its elements before the first pass runs; a lazy protocol would be a different feature and would take that guarantee away.

conformance/0032-instance-is-not-iterable.a24

class Bag;
var Items : List;
begin
    constructor Init (); begin this.Items := [1, 2]; end
end

var B := Bag ();
WriteLn (B.Items.Length);

for var X in B do WriteLn (X);

Shell

$ algc conformance/0032-instance-is-not-iterable.a24
Uncaught: Can only iterate a collection or a String.
2
exit: 70

conformance/0165-a-class-that-iterates.a24

class Bag;
var Items : List;
begin
    constructor Init (); begin this.Items := [10, 20, 30]; end
    function Elements (); begin Exit Items; end
end

for var X in Bag () do Write (Str (X) + ' ');
WriteLn ();

// The result is WALKED, not re-asked, so Elements may hand back another
// instance that also declares Elements and the chain resolves.  That is what
// stops a List whose Elements returns a List from recursing forever.
class Inner;
begin
    constructor Init (); begin end
    function Elements (); begin Exit ['a', 'b']; end
end

class Outer;
begin
    constructor Init (); begin end
    function Elements (); begin Exit Inner (); end
end

for var Y in Outer () do Write (Str (Y) + ' ');
WriteLn ();

// A PROTOCOL IS A NAME AND A SHAPE.  'Elements' taking an argument does not
// implement this one, so the class is simply not iterable -- and says so with
// the ordinary message rather than with a complaint about signatures.
class WrongShape;
begin
    constructor Init (); begin end
    function Elements (N : Integer); begin Exit [1]; end
end

try
    for var Z in WrongShape () do WriteLn (Z);
except
    on e : String do WriteLn (e);
end

// The same rule on the other two protocols.  'Contains ()' does not implement
// membership, and answering it TRUE was a wrong answer rather than an error.
class BadContains;
begin
    constructor Init (); begin end
    function Contains (); begin Exit True; end
end

try
    WriteLn (1 in BadContains ());
except
    on e : String do WriteLn (e);
end

// And 'ToString (N)' does not implement stringification, so the default stands.
class BadToString;
begin
    constructor Init (); begin end
    function ToString (N : Integer); begin Exit 'never'; end
end

WriteLn (Str (BadToString ()));

// Snapshotted like any other walk [STM-009]: Elements answers a whole
// collection, so the loop has its elements before the first pass runs.
class Growing;
var Items : List;
begin
    constructor Init (); begin this.Items := [1, 2]; end
    function Elements (); begin Exit Items; end
end

var G := Growing ();
for var W in G do
begin
    Write (Str (W) + ' ');
    G.Items.Add (99);
end
WriteLn ();

Shell

$ algc conformance/0165-a-class-that-iterates.a24
10 20 30 
a b 
Can only iterate a collection or a String.
Right operand of 'in' must be a collection or a String.
BadToString instance
1 2 

[TYP-012] A class exposes a field without parentheses and a method with them: a method named Length read as B.Length yields the function itself, printing <fn Length>, where a collection's Length yields its count.

A class may also declare a property: a member read without parentheses, whose read is the call [CLS-017].

The three are distinguished by their declarations, not by the call site. A field is a name in a var section, a method is function or procedure, and a property is property. Nothing at a use site says which — B.Count looks the same whichever it is — which is why the runtime decides, and why the emitter is told at the declaration rather than working it out at the call.

A BUILT-IN member reads the same way. L.Sort yields something callable and prints <fn Sort>, because it is the same kind of thing as a bound method. The spelling is the one the program wrote — a built-in member has no declaration to take a canonical one from, where a method prints the name its declaration used.

conformance/0033-no-computed-property.a24

class Box;
var Items : List;
begin
    constructor Init (); begin this.Items := [1, 2, 3]; end
    function Length (); begin Exit this.Items.Length; end
end

var B := Box ();

// With parentheses, the method runs.
WriteLn (B.Length ());

// Without them, the method itself is the value.
WriteLn (B.Length);

// A collection's Length, by contrast, is a count and needs no parentheses --
// which is exactly the asymmetry a class cannot reproduce.
WriteLn (B.Items.Length);

Shell

$ algc conformance/0033-no-computed-property.a24
3
<fn Length>
3

conformance/0149-a-built-in-member-as-a-value.a24

var L := [3, 1, 2];

WriteLn (L.Sort);
WriteLn (L.SORT);
WriteLn (L.Add);

// The other two receivers whose members come from the runtime rather than
// from a class.
var B := Buffer (4);
WriteLn (B.Append);

var F := TextFile ();
WriteLn (F.WriteLn);

// And it is callable, which is the point of reading one.
var Sort := L.Sort;
Sort ();
WriteLn (L[0]);

Shell

$ algc conformance/0149-a-built-in-member-as-a-value.a24
<fn Sort>
<fn SORT>
<fn Add>
<fn Append>
<fn WriteLn>
1

7. Properties of types and values

7.1 Assignability

[VAL-001] A value is assignable to a declaration when its type is the declared type, when the declaration is Any, when the value is nil, when its class inherits from the declared class, or when it widens to the declared type [VAR-004].

A value of type Any is not assignable to a written type; only the reverse holds [VAR-006].

conformance/0034-assignability.a24

class Animal; begin end
class Dog (Animal); begin end

// Same type.
var I : Integer := 1;
WriteLn (I);

// The DECLARATION is Any -- every value satisfies it.
var A : Any := Dog ();
WriteLn (A is Dog);

// nil satisfies every declared type.
var N : Dog := nil;
WriteLn (N = nil);

// A subclass stands where its parent is declared, upward only.
var P : Animal := Dog ();
WriteLn (P is Dog);
WriteLn (P is Animal);

// And a value that widens to the declared type [VAR-004].  The narrowing half
// of [VAL-002] is refused rather than truncated.
var W : Double := 1;
var T : String := 'a';
WriteLn (W);
WriteLn (T);

Shell

$ algc conformance/0034-assignability.a24
1
true
true
true
true
1.0
a

[VAL-002] Nothing else converts. The widenings are exactly the two of [VAR-004] — Integer to Double and Char to String — and they apply only at the assignment contexts of [VAR-017]. There is no narrowing, no conversion between a number and a String, and no user-defined conversion.

7.2 Type tests

[VAL-003] X is T is true when the runtime type of X is T, or is a class inheriting from T. Inheritance is followed upward only: a Dog is an Animal, and an Animal is not a Dog.

conformance/0035-type-tests.a24

class Animal; begin end
class Dog (Animal); begin end

// VAL-003: inheritance is followed UPWARD only.
WriteLn (Dog () is Dog);
WriteLn (Dog () is Animal);
WriteLn (Animal () is Dog);

// VAL-004: nil has no type to test -- not even the one it was declared as.
var N : Dog := nil;
WriteLn (N is Dog);
WriteLn (nil is Integer);

// VAL-005: Any is a declaration, never a runtime type -- but it is a legal
// name to write, unlike a name that denotes nothing [TYP-013].
WriteLn (1 is Any);
WriteLn (nil is Any);

// VAL-006: the type name folds case, as every name does [SRC-011].
WriteLn (1 is integer);
WriteLn (1 is INTEGER);
WriteLn (Dog () is dog);

Shell

$ algc conformance/0035-type-tests.a24
true
true
false
false
false
false
false
true
true
true

[VAL-004] nil is T is false for every T. A value that is not there has no type to test.

[VAL-005] X is Any is false for every X. Any is a declaration, never a runtime type.

Any is nonetheless a legal type name in is [TYP-013]. It denotes something; it just never matches.

[VAL-006] The type name in is is matched case-insensitively, so 1 is integer is true. This is [SRC-011] applied to a type name and is not a special case.

7.3 Casts

[VAL-007] X as T is a checked conversion. It tells the checker that the expression has type T, and verifies the claim when the program runs: if X is not a T, the cast raises.

nil satisfies every type [VAR-005] and therefore passes every cast.

as is the one construct that moves a value from untyped into typed [VAR-006], so it carries the whole weight of that boundary. A cast that could not fail would make the boundary a formality, and every declared type downstream of it a claim nothing had checked.

A cast that does not hold raises Cannot cast String to Integer.

The test is the one is uses [VAL-003] — the value's own type, or a class it inherits from — and deliberately the same code, so X as T and X is T cannot come to disagree about what T means.

conformance/0117-as-is-checked.a24

var Good : Any := 1;
WriteLn (Good as Integer);
WriteLn ((Good as Integer) + 1);

// A class hierarchy: a cast to a base class succeeds, by the rule 'is' uses.
class Animal; begin end
class Dog (Animal); begin end
var D : Any := Dog ();
WriteLn (D as Animal is Dog);

// nil satisfies every type [VAR-005] and therefore passes every cast.
var Nothing : Any := nil;
WriteLn (Nothing as Integer);

// And a cast that does not hold raises.
var Bad : Any := 'text';
WriteLn (Bad as Integer);

Shell

$ algc conformance/0117-as-is-checked.a24
Uncaught: Cannot cast String to Integer.
1
2
true
nil
exit: 70

7.4 Truthiness

[VAL-008] A value is falsey if it is nil, False, the Integer 0, or an enumeration member whose ordinal is 0. Every other value is truthy.

In particular these are all truthy: 0.0, the empty String '', the empty List [], the empty Map [:], and every Char.

Truthiness is independent of a value's contents. A collection is a thing, and a thing is there; if not S then therefore does not test emptiness, and if S.Length = 0 then is the only spelling that does.

conformance/0036-truthiness.a24

type Flag = (Off, On);

procedure Show (Label, V);
begin
    if V then WriteLn (Label + ' truthy');
    else WriteLn (Label + ' falsey');
end

// Falsey: nil, False, the Integer 0, and an enum member of ordinal 0.
Show ('nil       ', nil);
Show ('False     ', False);
Show ('0         ', 0);
Show ('enum ord 0', Off);

// Everything else is truthy -- including every empty thing, because
// truthiness is independent of a value's contents.
Show ('True      ', True);
Show ('1         ', 1);
Show ('0.0       ', 0.0);
Show ('empty str ', '');
Show ('a Char    ', 'a');
Show ('empty list', []);
Show ('empty map ', [:]);
Show ('enum ord 1', On);

// So this is the only spelling that tests emptiness.
// Length(S), not S.Length: a String has no .Length property interpreted,
// though it has one compiled -- see C-9.
var S := '';
WriteLn (Length (S) = 0);

Shell

$ algc conformance/0036-truthiness.a24
nil        falsey
False      falsey
0          falsey
enum ord 0 falsey
True       truthy
1          truthy
0.0        truthy
empty str  truthy
a Char     truthy
empty list truthy
empty map  truthy
enum ord 1 truthy
true

7.5 Equality

[VAL-009] = and <> promote numerically. 1 = 1.0 is true, and so is 0 = 0.0.

conformance/0037-equality.a24

// VAL-009: '=' and '<>' promote numerically.
WriteLn (1 = 1.0);
WriteLn (0 = 0.0);
WriteLn (1 <> 1.0);

// VAL-010: a Char is never equal to a String.  Both sides of the first are
// Chars, which is why it is true; Copy yields a String of length one.
WriteLn ('a' = 'a');
WriteLn (Copy ('abc', 0, 1) = 'a');

// VAL-012: nil equals nil.
WriteLn (nil = nil);

// VAL-011: collections and instances compare by IDENTITY, not contents.
WriteLn ([1, 2] = [1, 2]);

var L := [1, 2];
var M := L;
WriteLn (L = M);

class Dog; begin end
WriteLn (Dog () = Dog ());

Shell

$ algc conformance/0037-equality.a24
true
true
false
true
false
true
false
true
false

[VAL-010] A Char is never equal to a String — see [LEX-026]. 'a' and Copy('abc', 0, 1) are not equal.

Widening does not reach equality, and the asymmetry with [VAL-009] is deliberate. A numeric promotion has one obvious target — the wider of the two types — and converting toward it loses nothing. Char against String has no target at all: it is a change of representation rather than a widening of value, and picking a direction would mean = converting its operands differently depending on which side they arrived on.

The rule bites less often than it appears to. 'a' = 'a' is already true, because both sides are Chars; it is only reached when one side came from Copy, Str or a subscript. The complaint worth acting on is how easily a one-character String is produced by accident, not how = treats one.

[VAL-011] Class instances, collections and enumeration members compare by identity, not by contents. [1, 2] = [1, 2] is false: they are two collections. Two references to one collection are equal.

There is still no way for a class to say otherwise, and it is now a choice rather than an absence. A program may define +, -, *, / and div [EXP-020]; = is deliberately not on that list. Equality is coupled to membership by [VAL-013] — if X = Y then a collection holding Y contains X — and an object key hashes by its address, so defining = without a hash protocol to move with it would break a stated rule silently. That pairing is what Java's equals/hashCode discipline exists for, and it is the whole of what a program-defined = would have to settle first.

Ordering is different [VAL-014]. A class declaring Compare orders with < and its three companions, because ordering touches no hash and no membership — which is exactly why it was settled while equality was not.

[VAL-012] nil = nil is true.

7.6 Membership

[VAL-013] in, Contains and Map key lookup use the equality of [VAL-009]. Membership and equality are one relation: if X = Y then a collection holding Y contains X. 1 in [1.0] is true, and a Map holding the key 1 contains the key 1.0.

The hash is what pays for it, not the comparison. A Map and a Set bucket by a hash, so an Integer and a Double of one value must reach the same slot or Contains answers false for a key the Map holds. Every int32 converts to a double exactly, so both hash as a double and no range test can get it wrong.

-0.0, 0.0 and 0 are one key. They were three while the comparison was a memcmp, and the runtime said so in a comment this rule made stale.

NaN is the one departure, and this rule permits it. The rule is an implication: a pair that is not equal is unconstrained by it, and NaN = NaN is false. All NaNs are one key, because a Map that cannot find a key it holds is broken in a way no rule asks for.

One implementation, not two: ObjCollection delegates to the host's own Contains, so the interpreter's membership is the runtime's and the two cannot disagree.

conformance/0127-membership-follows-equality.a24

WriteLn (1 = 1.0);

WriteLn (1 in [1.0]);
WriteLn (1.0 in [1]);

var Keys := [1 : 'one'];
WriteLn (Keys.Contains (1.0));

var S := Set ([1]);
WriteLn (S.Contains (1.0));

// The hash is the real work, not the comparison.  A Map keyed 1 and then
// Put under 1.0 holds ONE key, because both reach the same slot.
var M := [1 : 'one'];
M.Put (1.0, 'again');
WriteLn (M.Length);
WriteLn (M.Get (1));

// -0.0 and 0.0 and 0 are one key.  They were three while the comparison was
// a memcmp, and the runtime said so in a comment that this rule made stale.
var Z := Set ();
Z.Add (0.0);
Z.Add (-0.0);
Z.Add (0);
WriteLn (Z.Length);

// Collections still compare by IDENTITY -- two Lists of the same contents are
// not equal, so membership does not find one by the other.
WriteLn ([1] in [[1]]);

Shell

$ algc conformance/0127-membership-follows-equality.a24
true
true
true
true
true
1
again
1
false

7.7 Ordering

[VAL-014] <, <=, > and >= apply to numbers and to text. Text is ordered lexicographically by code point, and a prefix sorts before what extends it: 'ab' < 'abc'. Anything else is Operands must be numbers.

A Char and a String compare as text. 'a' < 'ab' is true, and the one-character String Str ('a') orders identically to the Char 'a' — the two are still never equal [VAL-009], but they sit in one order.

Code points, not bytes. UTF-8 was designed so that byte order and code-point order agree, so an implementation comparing bytes is right by accident; this one is written in terms of code points so that it is right on purpose, and so that it cannot disagree with Ord.

Char ordering was by the FIRST BYTE and is now by the code point, which this rule never said either way. 'è' and 'é' are C3 A8 and C3 A9, share a lead byte, and compared equal — while Ord answered 232 and 233, so the language disagreed with itself about which came first. Fixed with this rule.

A class instance orders when its class declares Compare (Other) : Integer, answering negative, zero or positive. Without one, A < B on two instances is Operands must be numbers.

The fourth structural protocol, beside Contains, ToString [CLS-009] and Elements [TYP-011]; subscripting [TYP-010] is the fifth. A name and a shape: Compare taking one argument. There is no declaration keyword and no precedence question, because < already has a precedence [EXP-001].

Ordering costs nothing that equality would. It touches no hash and no membership, so unlike [VAL-013]'s coupling of = with in there is no second protocol that must move with it. That is why this is settled and equality is not.

Sort does NOT ask Compare [COL-013], and the asymmetry is forced rather than chosen. The interpreter delegates Sort to the host's, and the values it passes are ObjInstance — the compiler's class, not the program's — so the host would look for Compare there and never find it. Answering compiled and refusing interpreted is the divergence the corpus exists to catch, so neither does it. Sorting by Compare wants an interpreter inside ObjCollection and is a piece of work of its own.

Sort uses this ordering for TEXT [COL-013], rather than a second one that happens to agree. It compared with strcmp, which stops at an embedded zero a String is entitled to hold and which orders bytes rather than characters.

conformance/0166-text-is-ordered.a24

// Numbers and Chars still order as they did.

WriteLn (1 < 2);
WriteLn (1.5 >= 1.5);
WriteLn ('a' < 'b');

// Strings now do.
WriteLn ('ab' < 'cd');
WriteLn ('cd' < 'ab');
WriteLn ('ab' <= 'ab');
WriteLn ('' < 'a');

// A prefix sorts before what extends it.
WriteLn ('ab' < 'abc');
WriteLn ('abc' > 'ab');

// A Char and a String compare as TEXT.  The two are still never equal
// [VAL-009], but they sit in one order.
WriteLn ('a' < 'ab');
WriteLn ('ab' > 'a');
WriteLn (Str ('a') < 'b');

// By code point, so case is not folded: 'Z' is 90 and 'a' is 97.
WriteLn ('Z' < 'a');

// CODE POINTS, NOT BYTES.  'è' and 'é' are C3 A8 and C3 A9 in UTF-8: they
// share a lead byte, so comparing bytes would call them EQUAL while Ord
// answers 232 and 233 -- the language disagreeing with itself about order.
WriteLn (Ord ('è'), ' ', Ord ('é'));
WriteLn ('è' < 'é');
WriteLn ('é' <= 'è');

// Sort uses this same ordering [COL-013], not a second one that agrees.
var Names := ['pear', 'Apple', 'banana', 'apple'];
Names.Sort ();
WriteLn (Names);

var Accents := ['é', 'e', 'è', 'z'];
Accents.Sort ();
WriteLn (Accents);

// Mixing text with numbers is still refused.
try
    WriteLn ('ab' < 1);
except
    on e : String do WriteLn (e);
end

Shell

$ algc conformance/0166-text-is-ordered.a24
true
true
true
true
false
true
true
true
true
true
true
true
true
232 233
true
false
[Apple, apple, banana, pear]
[e, z, è, é]
Operands must be numbers.

conformance/0170-a-class-that-orders.a24

class Money;
var Cents : Integer;
begin
    constructor Init (C : Integer); begin this.Cents := C; end

    function Compare (Other : Money) : Integer; begin Exit Cents - Other.Cents; end
    function ToString () : String;              begin Exit Str (Cents); end
end

var A := Money (100);
var B := Money (200);

WriteLn (A < B, ' ', A > B, ' ', A <= B, ' ', A >= B);
WriteLn (A < A, ' ', A <= A, ' ', A >= A);

// EQUALITY IS UNTOUCHED and stays identity [VAL-011].  Ordering needs no
// hash and no membership, which is exactly why it is settled where equality is
// not: '=' is coupled to 'in' by [VAL-013], and a second protocol would have to
// move with it.
WriteLn (Money (100) = Money (100));
WriteLn (A = A);
WriteLn (Money (100) in [A]);

// Sort does NOT ask Compare, and the asymmetry is forced rather than chosen:
// the interpreter delegates Sort to the host's, whose values are the compiler's
// own instances and not the program's.  Answering compiled while refusing
// interpreted is the divergence this corpus exists to catch.
var L := [Money (300), Money (100)];
try
    L.Sort ();
except
    on e : String do WriteLn (e);
end

// A class without Compare does not order.
class Plain;
begin
    constructor Init (); begin end
end

try WriteLn (Plain () < Plain ()); except on e : String do WriteLn (e); end

// A protocol is a name AND a shape: 'Compare' taking no argument is not it.
class WrongShape;
begin
    constructor Init (); begin end
    function Compare () : Integer; begin Exit 0; end
end

try WriteLn (WrongShape () < WrongShape ()); except on e : String do WriteLn (e); end

// Compare must answer a number.
class BadAnswer;
begin
    constructor Init (); begin end
    function Compare (Other : Any) : Any; begin Exit 'soon'; end
end

try WriteLn (BadAnswer () < BadAnswer ()); except on e : String do WriteLn (e); end

Shell

$ algc conformance/0170-a-class-that-orders.a24
true false true false
false true true
false
true
false
Can only sort numbers against numbers, or text against text.
Operands must be numbers.
Operands must be numbers.
Compare must answer an Integer.

Ordering text used to mean comparing it character by character, which is what compiler/CEmitter.a24's TextLess did — a function the compiler wrote for itself because the language provided no operator. It is gone.

8. Declarations and scope

8.1 Blocks

[DCL-001] A block is begin … end and introduces a scope. A name declared inside it is not visible after it: reading one is Undefined variable 'X'.

conformance/0039-blocks-and-scope.a24

var Outer := 1;

begin
    // DCL-002: a block sees every name of the scopes enclosing it.
    WriteLn (Outer);

    var Inner := 2;
    WriteLn (Inner);
end

// DCL-008: a loop variable belongs to the loop, in both forms.
for var I := 0; I < 2; I := I + 1 do WriteLn (I);
for var E in [7] do WriteLn (E);

// DCL-001: a name declared inside a block is not visible after it.  This is a
// RUNTIME error, which is why the lines above have already printed.
WriteLn (Inner);

Shell

$ algc conformance/0039-blocks-and-scope.a24
Uncaught: Undefined variable 'Inner'.
1
2
0
1
7
exit: 70

[DCL-002] A block sees every name of the scopes enclosing it.

8.2 Shadowing

[DCL-003] A declaration shadows an outer one of the same name for the rest of its scope. The outer binding is untouched and reappears when the scope ends.

conformance/0040-shadowing.a24

procedure ShadowsAVar ();
var X : Integer := 1;
begin
    begin
        // DCL-003: the inner declaration shadows the outer for the rest of its
        // scope.  The outer binding is untouched.
        var X := 2;
        WriteLn (X);

        X := 3;
        WriteLn (X);
    end

    WriteLn (X);
end

procedure ShadowsAConst ();
const K := 10;
begin
    begin
        // DCL-004: a var may shadow a const.  The inner name is an ordinary
        // variable and may be assigned.
        var K := 20;
        K := 30;
        WriteLn (K);
    end

    // The outer constant is unaffected.
    WriteLn (K);
end

ShadowsAVar ();
ShadowsAConst ();

Shell

$ algc conformance/0040-shadowing.a24
2
3
1
30
10

[DCL-004] A var may shadow a const. The inner name is an ordinary variable and may be assigned; the outer constant is unaffected.

8.3 Declaration and use

[DCL-005] A local may not be read in its own initializer. var X := X; inside a block is refused with Can't read local variable in its own initializer., even where an outer X exists.

refusals/0015-own-initializer.a24

var X := 1;

begin
    var X := X;
    WriteLn (X);
end

Shell

$ algc refusals/0015-own-initializer.a24
Uncaught: Can't read local variable in its own initializer.
exit: 70

[DCL-006] A function or class declared at the top level of a file is visible throughout that file, wherever it is written. A call may precede the declaration, so a program may be organized from the top down.

A class is declared in two phases, which is what C gets from a header: every top-level class name is bound to an empty class before anything runs, and each is filled in — the same object, never replaced — when its declaration is reached. A subclass written above its parent therefore ends up holding the finished parent.

Binding the name is not enough, and it looks as though it were. With only the name bound, var D := Dog (); above the declaration built from an empty class: an object that answered D is Dog and had none of Dog's methods. A silent wrong answer, and worse than the Undefined variable it replaced. The class is built during the hoist, not merely named.

A class inheriting from something that is not a top-level class of this file is left where it stands, and that is what keeps [CLS-014] reachable: at hoist time a var has no value yet, so evaluating it would say Undefined variable in place of 'X' is not a class.

A parent from a module is one of those, which is where the limit of hoisting shows: a module runs at its uses [INI-003], so a class inheriting across a module boundary is built where its declaration stands and the import has to come first. Written above the uses, it is Undefined variable 'Shape'. — a fact about when the name is bound, not about inheritance.

Hoisting made an inheritance cycle reachable for the first time — a class could not previously be declared above its parent at all — so [CLS-013]'s check grew from a self-reference to a cycle.

conformance/0122-functions-are-hoisted.a24

WriteLn (Greet ());
WriteLn (Total (2, 3));

function Greet ();          begin Exit 'called from above'; end
function Total (A, B);      begin Exit A + B; end

// A class written below is usable above it.
var D := Dog ();
WriteLn (D is Dog);
WriteLn (D.Speak ());

class Dog;
begin
    constructor Init (); begin end
    function Speak (); begin Exit 'woof'; end
end

// A class may INHERIT from one written below it, which is the case that
// makes hoisting more than binding a name: the parent is bound as an empty
// shell and FILLED IN where its declaration stands, so the child holds the
// finished class because it is the same object.
class Puppy (Hound);
begin
    constructor Init (); begin end
end

class Hound;
begin
    constructor Init (); begin end
    function Speak (); begin Exit 'bay'; end
end

WriteLn (Puppy () is Hound);
WriteLn (Puppy ().Speak ());

// A VARIABLE is not hoisted: its initializer runs in order, and a name read
// before that has no value to give, and is an error rather than nil.
var Ready := 'declared in order';
WriteLn (Ready);

Shell

$ algc conformance/0122-functions-are-hoisted.a24
called from above
5
true
woof
true
bay
declared in order

conformance/0146-inherit-across-a-module.a24

uses 'modules/Shape';

WriteLn ('root, after the import');

class Circle (Shape);
begin
    constructor Init (); begin end
end

WriteLn (Circle ().Name ());
WriteLn (Circle () is Shape);

// A class of this file may still be inherited from either side of its own
// declaration, which is what hoisting is for.
class Puppy (Hound);
begin
    constructor Init (); begin end
end

class Hound;
begin
    constructor Init (); begin end
    function Name (); begin Exit 'hound'; end
end

WriteLn (Puppy ().Name ());

Shell

$ algc conformance/0146-inherit-across-a-module.a24
  Shape body
root, after the import
shape
true
hound

conformance/0147-inherit-before-the-import.a24

WriteLn ('root, before the import');

class Circle (Shape);
begin
    constructor Init (); begin end
end

uses 'modules/Shape';

WriteLn (Circle ().Name ());

Shell

$ algc conformance/0147-inherit-before-the-import.a24
Uncaught: Undefined variable 'Shape'.
root, before the import
exit: 70

refusals/0046-inherit-from-a-non-class.a24

var X := 1;

class C (X);
begin
end

Shell

$ algc refusals/0046-inherit-from-a-non-class.a24
Uncaught: 'X' is not a class.
exit: 70

[DCL-016] A variable or constant is not visible before its declaration has run. Its initializer is an expression evaluated in order [VAR-014], and a name read before that has no value to give — so it is an error, not nil.

The split is deliberate. A function or class declaration is complete as soon as it is read and has nothing to execute; a var has an initializer whose effects belong at the point it is written. Hoisting the first is what lets a file be read top-down; hoisting the second would silently substitute nil for a value that does not exist yet.

conformance/0044-variables-are-not-hoisted.a24

var Ready := 'declared';
WriteLn (Ready);

// A function IS visible above its declaration, and so is a class -- and a
// function called from up here reads the variables that exist WHEN IT RUNS,
// not the ones that existed where it was written.
WriteLn (Ahead ());
WriteLn (Thing ().ClassName);

function Ahead (); begin Exit Ready; end
class Thing; begin end

// Writing to a name does not bind it either: a variable is bound by its
// declaration, so this is the same error a read gets.
try
    Absent := 5;
except
    on e : String do WriteLn (e);
end

var Absent := 1;

// A variable is not visible before its declaration has run.  Its initializer
// is an expression evaluated in order, and a name read before that has no
// value to give -- so this is an error, not nil.
WriteLn (Later);

var Later := 7;

Shell

$ algc conformance/0044-variables-are-not-hoisted.a24
Uncaught: Undefined variable 'Later'.
declared
declared
Thing
Undefined variable 'Absent'.
exit: 70

refusals/0033-a-variable-is-not-hoisted.a24

WriteLn (Later);

var Later := 7;

Shell

$ algc refusals/0033-a-variable-is-not-hoisted.a24
Uncaught: Undefined variable 'Later'.
exit: 70

[DCL-007] A free name in a function body is resolved when the body runs, not where it is written. Two functions may therefore call each other, provided neither is called before both declarations have run.

conformance/0041-mutual-recursion.a24

function IsEven (N);
begin
    if N = 0 then Exit True;
    Exit IsOdd (N - 1);
end

function IsOdd (N);
begin
    if N = 0 then Exit False;
    Exit IsEven (N - 1);
end

WriteLn (IsEven (4));
WriteLn (IsEven (7));
WriteLn (IsOdd (7));

Shell

$ algc conformance/0041-mutual-recursion.a24
true
false
true

This is why mutual recursion works even under the current implementation, where [DCL-006] does not: the call inside a body is resolved late, so only a call at the top level, above the declaration, meets the missing binding.

8.4 Loop variables

[DCL-008] A variable declared in a for header belongs to the loop, in both forms, and is not visible after it ends.

For the counted form this follows from [DCL-001] rather than being a rule of its own: for desugars into a block holding the initializer and a while, so the variable is scoped because it is inside a block.

8.5 this and super

[DCL-009] this outside a class is refused with Can't use 'this' outside a class.

refusals/0016-this-outside-a-class.a24

Shell

$ algc refusals/0016-this-outside-a-class.a24

[DCL-010] super outside a class is refused with Can't use 'super' outside a class., and inside a class having no superclass with Can't use 'super' in a class with no superclass.

refusals/0017-super-outside-a-class.a24

Shell

$ algc refusals/0017-super-outside-a-class.a24

refusals/0018-super-with-no-superclass.a24

class Lonely;
begin
    procedure Attempt ();
    begin
        super.Something ();
    end
end

Lonely ().Attempt ();

Shell

$ algc refusals/0018-super-with-no-superclass.a24
Uncaught: Can't use 'super' in a class with no superclass.
exit: 70

8.6 Visibility

[DCL-011] private: and public: are section markers within a class or object, each governing the members that follow it. A member declared under no marker is public.

conformance/0042-visibility.a24

class Counter;
private:
var Count : Integer;
public:
var Name : String;

begin
    constructor Init (N);
    begin
        this.Count := 0;
        this.Name  := N;
    end

    // DCL-012: the body starts public however the header ended.  The header
    // above closed under 'public:', and this method is reachable regardless.
    procedure Bump (); begin this.Count := this.Count + 1; end

    function Value (); begin Exit this.Count; end

    // DCL-013: privacy belongs to the CLASS, not to the object -- a method may
    // reach the private members of another instance of its own class.
    function Total (Other : Counter);
    begin
        Exit this.Count + Other.Count;
    end
end

var A := Counter ('a');
var B := Counter ('b');

A.Bump ();
A.Bump ();
B.Bump ();

// DCL-011: a public member is reachable from outside.
WriteLn (A.Name);
WriteLn (A.Value ());

WriteLn (A.Total (B));

Shell

$ algc conformance/0042-visibility.a24
a
2
3

refusals/0019-private-through-a-typed-receiver.a24

class Counter;
private:
var Count : Integer;
public:
begin
    constructor Init (); begin this.Count := 0; end
end

var C : Counter := Counter ();
WriteLn (C.Count);

Shell

$ algc refusals/0019-private-through-a-typed-receiver.a24
Uncaught: 'Count' is private to Counter.
exit: 70

[DCL-012] The body starts public however the header ended. A private: in the header does not carry across begin.

[DCL-013] Privacy belongs to the class, not to the object. A method may reach the private members of another instance of its own class.

[DCL-014] A subclass does not reach what its parent hid. Reading a parent's private member through a receiver declared as the parent is refused with 'N' is private to P.

refusals/0020-subclass-does-not-reach-what-a-parent-hid.a24

class Parent;
private:
var Secret : Integer;
public:
begin
    constructor Init (); begin this.Secret := 1; end
end

class Child (Parent);
begin
    function Peek (P : Parent); begin Exit P.Secret; end
end

WriteLn (Child ().Peek (Parent ()));

Shell

$ algc refusals/0020-subclass-does-not-reach-what-a-parent-hid.a24
Uncaught: 'Secret' is private to Parent.
exit: 70

[DCL-015] private: is advisory. It is checked statically, and only where the receiver's type is known. Reached through a receiver declared Any, or through a bare name inside a method — which resolves through this, and this has no type — a private member is readable and writable from anywhere.

var C : Any := Counter ();
WriteLn (C.Count);        // the private field, read
C.Count := 99;            // and written

This is normative: private: states an intention and buys a diagnostic wherever types are written down. It is not a boundary, and a program must not rely on it as one. Both processors agree, so it is a property of the language rather than of one implementation.

The guarantee is therefore strongest exactly where it is least needed — in well-annotated code — and absent from the code most likely to be reaching somewhere it should not. That is an honest description of a checker in a gradually typed language, not an accident.

as becoming a checked conversion [VAL-007] does not close this. Member access is not one of the assignment contexts [VAR-017], so nothing obliges a receiver to be narrowed before it is read through.

conformance/0043-visibility-is-advisory.a24

class Counter;
private:
var Count : Integer;
public:
begin
    constructor Init (); begin this.Count := 5; end
end

// Through a receiver declared Any, the static check cannot see the type, and
// the private field is readable...
var C : Any := Counter ();
WriteLn (C.Count);

// ... and writable.
C.Count := 99;
WriteLn (C.Count);

Shell

$ algc conformance/0043-visibility-is-advisory.a24
5
99

9. Expressions

9.1 Precedence and associativity

[EXP-001] Operators bind in this order, tightest first:

conformance/0045-precedence.a24

WriteLn (1 + 2 * 3);           // * over +
WriteLn ((1 + 2) * 3);         // parentheses override
WriteLn (-2 * 3);              // unary over *
WriteLn (1 + 1 = 2);           // + over =
WriteLn (1 < 2 = True);        // < over =
WriteLn (not True and False);  // not over and
WriteLn (True or False and False);   // and over or
WriteLn (False and True or True);    // and over or, the other way

// EXP-002: one level is left-associative.  Right-associative, these would be
// 11 and 18.
WriteLn (10 - 2 - 3);
WriteLn (12 / 2 / 3);

Shell

$ algc conformance/0045-precedence.a24
7
9
-6
true
true
false
true
true
5
2.0

1 + 2 * 3 is 7, -2 * 3 is -6, not True and False is false, True or False and False is true, and False = False and False is false. Each distinguishes its pair. Verified.

[EXP-002] Binary operators of one level are left-associative: 10 - 2 - 3 is 5 and 12 / 2 / 3 is 2.

[EXP-003] as binds tightly, at the level of unary - and not. It applies to the operand beside it and to nothing further: A and B as C is A and (B as C), and A as Integer > 3 is (A as Integer) > 3.

The binding stopped being cosmetic when as became a checked conversion [VAL-007]. Under the old reading False and 5 as Integer was (False and 5) as Integer — a Boolean cast to Integer, which raises. It is now False and (5 as Integer), which is False.

conformance/0118-as-binds-tightly.a24

var A : Any := 5;

// Under the old precedence this did not parse at all: the cast consumed the
// expression and the comparison had nothing to attach to.
WriteLn (A as Integer > 3);
WriteLn (A as Integer + 1);

// The line that distinguishes the two readings now that a cast is checked.
// 'and' yields its LEFT operand when that is falsey, so the old reading was
// '(False and 5) as Integer' -- a Boolean cast to Integer, which raises.  The
// new one casts 5, which is already an Integer, and the conjunction is False.
WriteLn (False and 5 as Integer);

// And the ordinary case: the cast applies to B, not to the conjunction.
WriteLn (True and A as Integer);

Shell

$ algc conformance/0118-as-binds-tightly.a24
true
6
false
5

9.2 Arithmetic

[EXP-004] Integer arithmetic yields an Integer — except /, which is real division and always answers a Double: 7 / 2 is 3.5, -7 / 2 is -3.5, and 4 / 2 is 2.0 rather than 2.

/ means one thing. It used to mean two — truncating division on two Integers and real division as soon as a Double reached it — so X / Y could not be read where X was declared Any, and an edit far from the division could silently change which operation it was. A symbol whose meaning depends on the run-time types of its operands is the one thing arithmetic cannot afford to have.

Truncation did not go anywhere; it got a name. div [EXP-018] and mod [EXP-021] are the Integer pair, they refuse a Double rather than converting it, and they are the only operators that raise on a zero divisor. A program that means integer division now says so.

conformance/0046-arithmetic.a24

// EXP-004: Integer arithmetic yields an Integer -- EXCEPT '/', which is real
// division and answers a Double however it is reached.
WriteLn (7 * 2);
WriteLn (7 - 2);
WriteLn (7 / 2);
WriteLn (-7 / 2);

// It divides exactly, so a result with no fraction is a Double all the same.
WriteLn (4 / 2);
WriteLn (4 / 2 is Double);

// 'div' and 'mod' are how a program asks for the Integer pair [EXP-018],
// [EXP-021].
WriteLn (7 div 2);
WriteLn (7 mod 2);

// EXP-005: a Double on either side promotes the operation and the result.
WriteLn (7.0 / 2);
WriteLn (7 / 2.0);
WriteLn (1 + 2.0);
WriteLn (2.0 * 3);
WriteLn ((1 + 2.0) is Double);

Shell

$ algc conformance/0046-arithmetic.a24
14
5
3.5
-3.5
2.0
true
3
1
3.5
3.5
3.0
6.0
true

[EXP-005] A Double on either side promotes the operation and the result: 7.0 / 2 and 7 / 2.0 are both 3.5, and 1 + 2.0 is 3.0.

[EXP-006] Division by zero is not an error for /. It yields Infinity, -Infinity or NaN, and the program continues. div and mod raise Division by zero.

Which of the two happens is decided by the operator, not by the types that reached it. / is real division [EXP-004], so IEEE 754 answers it and there is nothing to fault; div and mod take Integers only, and there is no integer infinity for them to return.

This used to depend on the operands instead — 1 / 0 raised where 1.0 / 0 did not — so [EXP-005] promoting an Integer the moment it met a Double could move a division from one category to the other from far away. The rule now reads off the symbol, which is the thing the programmer wrote.

conformance/0047-division-by-zero.a24

// '/' is real division [EXP-004], so a zero divisor is a value rather than a
// fault -- and it does not matter which types reached it.
WriteLn (1.0 / 0);
WriteLn (-1.0 / 0);
WriteLn (0.0 / 0);
WriteLn (1 / 0);
WriteLn (-1 / 0);
WriteLn (0 / 0);

// 'div' and 'mod' are the ones that raise, because they are the ones whose
// operands really are Integers.
try
    WriteLn (1 div 0);
except
    on e : String do WriteLn (e);
end

try
    WriteLn (1 mod 0);
except
    on e : String do WriteLn (e);
end

Shell

$ algc conformance/0047-division-by-zero.a24
Infinity
-Infinity
NaN
Infinity
-Infinity
NaN
Division by zero.
Division by zero.

[EXP-007] Integer arithmetic never overflows: a result too large for the machine's width grows to hold it [LEX-018].

A Double does not, and the asymmetry is deliberate. A Double follows IEEE 754, so 1.0 / 0 is Infinity [EXP-006] rather than an error and precision is lost silently past 2⁵³. An Integer is exact and unbounded; a Double is approximate and bounded, and a program choosing between them is choosing between those.

A mixed expression is Double arithmetic [EXP-005], so 2147483647 + 1.0 is 2.147483648E9 — the Integer promotes to a Double and the exactness goes with it.

[EXP-018] A div B is integer division. It truncates toward zero — 7 div 2 is 3 and -7 div 2 is -3 — and refuses anything that is not an Integer, with div expects Integers. A zero divisor is Division by zero.

It is the only spelling of truncation. / is real division whatever it divides [EXP-004], so a program that wants a quotient without a fraction has to say div, and a reader who sees div knows what was meant without knowing the types.

Refusing a Double rather than truncating it. A programmer writing div has said the operands are Integers; if they are not, that is a mistake worth reporting rather than a conversion worth performing silently.

It grows with what it divides, since an Integer is unbounded [LEX-018].

It binds as * and / do — a different operation, not a different precedence, so A + B div C groups the way A + B / C does.

conformance/0155-integer-division.a24

WriteLn (7 div 2);
WriteLn (-7 div 2);
WriteLn (7 div 2 is Integer);

// It binds as '*' and '/' do, so this groups as 'A + (B div C)'.
WriteLn (1 + 8 div 2);

// It grows with the Integer it divides [LEX-018].
WriteLn (9223372036854775807 * 2 div 2);

// A Double is REFUSED rather than truncated.  A programmer writing 'div' has
// said the operands are Integers, so a Double is a mistake worth reporting.
try
    WriteLn (7.0 div 2);
except
    on e : String do WriteLn (e);
end

try
    WriteLn (7 div 0);
except
    on e : String do WriteLn (e);
end

// '/' is real division [EXP-004], which is what leaves 'div' the one spelling
// of truncation.
WriteLn (7 / 2);
WriteLn (7.0 / 2);

Shell

$ algc conformance/0155-integer-division.a24
3
-3
true
5
9223372036854775807
div expects Integers.
Division by zero.
3.5
3.5

[EXP-021] A mod B is the remainder of A div B, and its sign follows the dividend: -7 mod 3 is -1 and 7 mod -3 is 1. It refuses anything that is not an Integer, with mod expects Integers., and a zero divisor is Division by zero.

It is div's partner and takes div's terms, deliberately. The two are one operation read two ways — A = (A div B) * B + (A mod B) holds for every pair of Integers — so a rule the quotient obeys and the remainder does not would be a rule about spelling rather than about arithmetic.

The sign follows the dividend because the truncation does. div truncates toward zero [EXP-018], which fixes the remainder's sign; a mod that answered a non-negative result would be describing a flooring division this language does not have.

It was a function until it was an operator. Mod(A, B) was a built-in [RT-011], which left div spelled as an operator and its partner spelled as a call — an asymmetry with no argument behind it, since Turbo Pascal had mod as an operator all along. The built-in was removed rather than kept beside the operator, because two spellings of one operation is the thing the asymmetry was already costing.

conformance/0185-integer-remainder.a24

WriteLn (7 mod 3);
WriteLn (6 mod 3);
WriteLn (7 mod 3 is Integer);

// THE SIGN FOLLOWS THE DIVIDEND, which is what truncating toward zero makes
// it [EXP-018].
WriteLn (-7 mod 3);
WriteLn (7 mod -3);
WriteLn (-7 mod -3);

// It binds as '*' and 'div' do, so this groups as 'A + (B mod C)'.
WriteLn (1 + 8 mod 3);

// It grows with the Integer it divides [LEX-018].
WriteLn (9223372036854775807 * 2 mod 1000);

// 'div' and 'mod' are one operation read two ways.
var A := 17;
var B := 5;
WriteLn (A = (A div B) * B + (A mod B));

// A Double is REFUSED rather than truncated, on 'div's terms.
try
    WriteLn (7.0 mod 2);
except
    on e : String do WriteLn (e);
end

try
    WriteLn (7 mod 0);
except
    on e : String do WriteLn (e);
end

Shell

$ algc conformance/0185-integer-remainder.a24
1
0
true
-1
1
-1
3
614
true
mod expects Integers.
Division by zero.

[EXP-008] + concatenates when either operand is text, converting the other. 'ab' + 1 is ab1, 1 + 'ab' is 1ab, and 'a' + 'b' — two Chars — is the String ab.

A Char mixed with a number is refused: 'a' + 1 is A Char and a number cannot be added; use Succ or Str. So is 'a' - 1, with use Pred.

A Char is an ordinal, so the mixed form reads two ways — step the character, or join it to the text 1 — and rather than pick one silently the language makes the program say which: Succ ('a') [RT-020] for the step, Str ('a') + 1 for the join.

It used to concatenate, and that quietly widened the Char. Str is how a Char becomes a String, which is why Line ('{') must be declared Any [LEX-026] — yet 'a' + 1 and Str ('a') + 1 both gave a1, so in this one place the widening happened without being asked for and Str was decorative. [VAR-004] specifies widening to reach a written type, at a declaration; + in an expression was never that rule being applied.

A String mixed with a number still concatenates. A String is not an ordinal, so 'ab' + 1 has only one reading and nothing to disambiguate.

conformance/0167-character-arithmetic.a24

// The distance between two Chars, as an Integer.

WriteLn ('z' - 'a');
WriteLn ('a' - 'z');
WriteLn ('a' - 'a');

// Code points, so this is the same 232 and 233 that Ord answers.
WriteLn ('é' - 'è');

// Stepping, on a Char and on an Integer.
WriteLn (Succ ('a'), ' ', Pred ('b'));
WriteLn (Succ (5), ' ', Pred (5));
WriteLn (Succ ('è'));

// A CHAR MIXED WITH A NUMBER IS REFUSED.  A Char is an ordinal, so 'a' + 1
// reads two ways -- step the character, or join it to the text '1' -- and
// rather than pick one silently the language makes the program say which.
try WriteLn ('a' + 1); except on e : String do WriteLn (e); end
try WriteLn (1 + 'a'); except on e : String do WriteLn (e); end
try WriteLn ('a' - 1); except on e : String do WriteLn (e); end

// Str is how a Char widens, and now it means something: these two differ.
WriteLn (Str ('a') + 1);
WriteLn (Succ ('a'));

// A STRING mixed with a number still concatenates.  A String is not an
// ordinal, so it has only one reading and nothing to disambiguate.
WriteLn ('ab' + 1);
WriteLn (1 + 'ab');

// And two Chars still concatenate, which is what Turbo Pascal does.
WriteLn ('a' + 'b');

// Anything that is not an ordinal has no Succ.
try WriteLn (Succ (True));  except on e : String do WriteLn (e); end
try WriteLn (Succ ('ab'));  except on e : String do WriteLn (e); end

Shell

$ algc conformance/0167-character-arithmetic.a24
25
-25
0
1
b a
6 4
é
A Char and a number cannot be added; use Succ or Str.
A Char and a number cannot be added; use Succ or Str.
A Char and a number cannot be subtracted; use Pred.
a1
b
ab1
1ab
ab
Succ failed: 'true' has no ordinal.
Succ failed: 'ab' has no ordinal.

[EXP-019] - on two Chars answers the Integer distance between their code points: 'z' - 'a' is 25.

The only arithmetic a Char takes, and it is the one that cannot be read two ways: subtracting two ordinals is a distance and nothing else. Stepping is Succ and Pred [RT-020], joining is Str and + [EXP-008].

Turbo Pascal has neither, and this is a deliberate departure from it. TP answers a distance with Ord (X) - Ord (Y), which stays available and says the same thing at greater length.

[EXP-020] A class may define +, -, *, / and div for its own instances, and unary -, and mod. The member is named for the operator, and takes one argument — or none, which is what makes it the unary form.

class Money;
var Cents : Integer;
begin
    constructor Init (C : Integer); begin this.Cents := C; end

    operator + (Other : Money) : Money; begin Exit Money (Cents + Other.Cents); end
    operator * (N : Integer)   : Money; begin Exit Money (Cents * N); end
    operator - ()              : Money; begin Exit Money (-Cents); end
end

A closed list, and it has to be. A new operator would need a precedence and an associativity, and [EXP-001] is a fixed table of seven levels with nowhere to put one. These six already have a place in it. operator = is refused with An operator must be one of + - * / div mod.

The LEFT operand decides, as a receiver does everywhere else in this language: Money * 3 is a Money and 3 * Money is Operands must be numbers. An operator is a member, and a member is reached through the value on its left.

Unary and binary are told apart by ARITY, as the two forms of subscript are [TYP-010]. operator - (Other) is subtraction and operator - () is negation; the language tells arities apart everywhere, so neither form needs a word of its own.

This is the one place a keyword was chosen over a protocol, after six protocols in a row. Compare [VAL-014], Get and Put are not translations of operators — Compare yields four of them, Get and Put are two halves of one — while a Plus method would be a pure synonym for +, a name added without a concept. Where the name says something the symbol does not, the protocol wins; here it would not.

not and := are not on the list. not tests truthiness, which [VAL-008] defines for every value, so a type overloading it lies about a language-wide property rather than defining its own behavior. := is outside the mechanism entirely: dispatch is on values [FUN-013], and the left of an assignment is a location.

div and mod are both here, and that is newer than this rule. Mod was once a built-in function [RT-011] while div was an operator, so a class could define one and never the other. Making mod an operator [EXP-021] closed the gap, and a class that defines div can now define its partner.

conformance/0172-a-class-that-computes.a24

class Money;
var Cents : Integer;
begin
    constructor Init (C : Integer); begin this.Cents := C; end

    operator + (Other : Money) : Money;   begin Exit Money (Cents + Other.Cents); end
    operator - (Other : Money) : Money;   begin Exit Money (Cents - Other.Cents); end
    operator * (N : Integer)   : Money;   begin Exit Money (Cents * N); end
    operator div (N : Integer) : Money;   begin Exit Money (Cents div N); end
    operator mod (N : Integer) : Money;   begin Exit Money (Cents mod N); end

    // UNARY, told apart from subtraction by ARITY -- as the two forms of
    // subscript are.  The language tells arities apart everywhere, so neither
    // form needs a word of its own.
    operator - ()              : Money;   begin Exit Money (-Cents); end

    function ToString () : String;        begin Exit Str (Cents); end
end

var A := Money (100);
var B := Money (250);

WriteLn (A + B);
WriteLn (B - A);
WriteLn (A * 3);
WriteLn (B div 5);
WriteLn (B mod 7);
WriteLn (-A);

// It composes with the other protocols: an operator answering an instance is
// an instance like any other.
WriteLn ((A + B) - A);

// THE LEFT OPERAND DECIDES, as a receiver does everywhere else in this
// language.  An operator is a member, and a member is reached through the value
// on its left.
try
    WriteLn (3 * A);
except
    on e : String do WriteLn (e);
end

// A class defining no operator is unchanged.
class Plain;
begin
    constructor Init (); begin end
end

try
    WriteLn (Plain () + Plain ());
except
    on e : String do WriteLn (e);
end

Shell

$ algc conformance/0172-a-class-that-computes.a24
350
150
300
50
5
-100
250
Operands must be numbers.
Operands must be two numbers, or two strings.

refusals/0172-an-operator-not-on-the-list.a24

class Pair;
var Left, Right : Integer;

begin
    constructor Init (L : Integer, R : Integer); begin this.Left := L; this.Right := R; end

    operator = (Other : Pair) : Boolean; begin Exit Left = Other.Left; end
end

Shell

$ algc refusals/0172-an-operator-not-on-the-list.a24
Uncaught: An operator must be one of + - * / div mod.
[ERROR] refusals/0172-an-operator-not-on-the-list.a24: An operator must be one of + - * / div mod.
[ERROR] 7 |     operator = (Other : Pair) : Boolean; begin Exit Left = Other.Left; end
[ERROR]   |              ^
exit: 70

9.4 Logical operators

[EXP-009] and and or short-circuit. The right operand is evaluated only when the left does not decide the result.

conformance/0048-logical-operators.a24

var Ran := 0;

function Boom ();
begin
    Ran := Ran + 1;
    Exit True;
end

// EXP-009: the right operand is evaluated only when the left does not decide.
Ran := 0;  var A := False and Boom ();  WriteLn (Ran);
Ran := 0;  var B := True  or  Boom ();  WriteLn (Ran);
Ran := 0;  var C := True  and Boom ();  WriteLn (Ran);
Ran := 0;  var D := False or  Boom ();  WriteLn (Ran);

// EXP-010: both test truthiness rather than requiring a Boolean, and yield an
// OPERAND rather than a Boolean.
WriteLn (0 or 'text');
WriteLn ('text' and 7);
WriteLn (nil or 'fallback');

Shell

$ algc conformance/0048-logical-operators.a24
0
0
1
1
text
7
fallback

[EXP-010] Both operators test truthiness [VAL-008] rather than requiring a Boolean.

9.5 Calls

[EXP-011] A call checks arity. A mismatch is Expected N arguments but got M.

Except where a count is not the callee's rule. A subprogram whose last parameter gathers trailing arguments [FUN-005] has a different count by design, and reports No matching signature for function. instead — naming the count would send the reader to look at the wrong thing, since what refused the call was the element type. Write and WriteLn take any number of values [RT-001] and so can never fail this way at all.

conformance/0049-call-failures.a24

function One (A); begin Exit A; end

WriteLn (One (1));

// Too FEW is a failure too, and the more dangerous one: the missing argument
// has to be diagnosed rather than read from wherever the call left off.
try
    WriteLn (One ());
except
    on e : String do WriteLn (e);
end

class Box;
begin
    constructor Init (A); begin end
    function Only (A); begin Exit A; end
end

try
    WriteLn (Box (1).Only (1, 2));
except
    on e : String do WriteLn (e);
end

try
    WriteLn (Box (1).Only ());
except
    on e : String do WriteLn (e);
end

// Construction reports the counts, like any other call with one signature.
try
    WriteLn (Box (1, 2));
except
    on e : String do WriteLn (e);
end

// And uncaught, which is how the failure ends a program.
WriteLn (One (1, 2));

Shell

$ algc conformance/0049-call-failures.a24
Uncaught: Expected 1 arguments but got 2.
1
Expected 1 arguments but got 0.
No matching signature for function.
No matching signature for function.
Expected 1 arguments but got 2.
exit: 70

conformance/0145-a-builtin-with-the-wrong-arity.a24

WriteLn (Length ('abc'));

try
    WriteLn (Length ('a', 'b'));
except
    on e : String do WriteLn (e);
end

try
    WriteLn (Ord ());
except
    on e : String do WriteLn (e);
end

// Two built-ins take nothing OR one value -- Set and Buffer [RT-001] -- so
// 'expected' is not always a single number.
//
// And Write and WriteLn take ANY number of values, so neither of these is a
// wrong call at all: no argument is the newline on its own, and several are
// run together with nothing between them.  This is the one place a built-in's
// count is never wrong.
WriteLn ();
WriteLn ('a', 'b');

// A name nothing declares is the other failure, for contrast.
try
    WriteLn (Nonexistent (1));
except
    on e : String do WriteLn (e);
end

Shell

$ algc conformance/0145-a-builtin-with-the-wrong-arity.a24
3
Expected 1 arguments but got 2.
Expected 1 arguments but got 0.

ab
Undefined variable 'Nonexistent'.

[EXP-012] Calling something that is neither a function nor a class is Can only call functions and classes.

[EXP-013] Where a name is overloaded, selection is made on the whole signature — the number of arguments and the type of each — and is made at run time, from the arguments actually passed.

Run-time selection is required, not an implementation choice. The type system is gradual, so an argument's declared type may be Any or absent while its value has a definite type: var A : Any := 1; passed to a name overloaded on Integer and String selects the Integer. No static rule could reach that, and an implementation must not resolve overloads at compile time on declared types alone.

An argument may name the parameter it fills — Log (Level: 'warn'). The arguments are then put in declaration order, so the order at the call site is free.

The names select the signature, which is why the feature exists. Run-time selection above stays the rule, and stays right; what a programmer who does know which overload they mean has lacked is a way to say so. A name identifies one signature, where values only describe something several signatures might accept.

Positional arguments come first and named ones after. A positional argument following a named one is refused, as is a parameter supplied twice, and a name no parameter has. This is also what spares [FUN-005] a rule of its own: gathering takes trailing positional arguments, and positional arguments end exactly where naming begins — so naming the absorbing parameter turns gathering off without anything having to say so.

: rather than =>, because the language already has this colon. [k : v] is a Map literal [COL-001]: a name on the left, a value on the right, read by parsing an expression and then looking for a colon. A named argument means the same thing and parses the same way. The ambiguity that usually rules : out is absent — a colon in expression position normally meets a conditional expression's ? :, and this language has none, because ? is an identifier mark [LEX-008] and Gate? is one word.

A built-in has no named parameters. Its parameters are not declared in this language at all — they exist only as a count [RT-001] — so there is no name to write, and WriteLn (V: 'abc') is A built-in has no named parameters.

conformance/0160-named-arguments.a24

procedure Log (Level : String, Message : String);
begin
    WriteLn (Level + ': ' + Message);
end

Log ('warn', 'disk');
Log (Level: 'warn', Message: 'disk');

// The order at the call site is free; the order that matters is the
// declaration's.
Log (Message: 'disk', Level: 'warn');

// Positional first, named after.
Log ('warn', Message: 'disk');

// A name folds like every other name [SRC-011].
Log (level: 'warn', MESSAGE: 'disk');

// Two subprograms of one name, told apart by the names alone.
procedure Note (Level : String, Message : String); begin WriteLn ('two'); end
procedure Note (Code : Integer);                   begin WriteLn ('one'); end

Note (Code: 7);
Note (Level: 'warn', Message: 'x');

// Constructing an instance is a call to the constructor, so its parameters are
// named the same way [CLS-002].
class Dog;
begin
    constructor Init (Name : String, Age : Integer);
    begin
        WriteLn (Name + ' is ' + Str (Age));
    end

    procedure Fetch (What : String, Times : Integer);
    begin
        WriteLn (What + ' x' + Str (Times));
    end
end

var D := Dog (Age: 3, Name: 'Rex');

// And a method, whose class is not known until the receiver is.
D.Fetch (Times: 2, What: 'ball');

// A subprogram held in a variable keeps its parameter names.
var F := Log;

F (Message: 'held', Level: 'warn');

// Naming the absorbing parameter turns absorption OFF, and needs no rule to
// do it [FUN-005]: an arrangement fills every slot exactly once, so the
// arranged call has precisely the declared arity and the exact pass takes it
// before absorption is ever reached.
procedure Take (Label : String, Items : List of Integer);
begin
    WriteLn (Label + ' ' + Str (Items.Length));
end

Take ('a', 1, 2, 3);
Take ('a', Items: [1, 2, 3]);
Take (Items: [1], Label: 'a');

// A name no parameter has.
try
    Log (Levl: 'warn', Message: 'x');
except
    on e : String do WriteLn (e);
end

// A parameter supplied twice.
try
    Log (Level: 'a', Level: 'b');
except
    on e : String do WriteLn (e);
end

// A BUILT-IN has no named parameters.  Its parameters are not declared in
// this language at all -- they exist only as a count -- so there is no name to
// write [RT-001].
try
    WriteLn (V: 'abc');
except
    on e : String do WriteLn (e);
end

Shell

$ algc conformance/0160-named-arguments.a24
warn: disk
warn: disk
warn: disk
warn: disk
warn: disk
one
two
Rex is 3
ball x2
warn: held
a 3
a 3
a 1
No matching signature for function.
No matching signature for function.
A built-in has no named parameters.

refusals/0160-a-positional-argument-after-a-named-one.a24

procedure Log (Level : String, Message : String);
begin
    WriteLn (Level + ': ' + Message);
end

Log (Level: 'warn', 'disk');

Shell

$ algc refusals/0160-a-positional-argument-after-a-named-one.a24
Uncaught: A positional argument cannot follow a named one.
exit: 70

conformance/0050-overload-selection.a24

class M;
begin
    function Take (I : Integer);          begin Exit 'integer';      end
    function Take (S : String);           begin Exit 'string';       end
    function Take (C : Char);             begin Exit 'char';         end
    function Take (A : Integer, B : Integer); begin Exit 'two integers'; end
end

var X := M ();

// EXP-013: selection is on the WHOLE signature -- count and each type.
WriteLn (X.Take (1));
WriteLn (X.Take ('ab'));
WriteLn (X.Take ('a'));
WriteLn (X.Take (1, 2));

// Selection is at RUN TIME, from the value actually passed.  A's declared
// type is Any; no static rule could reach the Integer overload from that.
var A : Any := 1;
WriteLn (X.Take (A));

var B : Any := 'ab';
WriteLn (X.Take (B));

// EXP-014: an exact match is preferred.  'a' is a Char and takes the Char
// overload rather than widening to the String one.
WriteLn (X.Take ('a'));

Shell

$ algc conformance/0050-overload-selection.a24
integer
string
char
two integers
integer
string
char

[EXP-014] An overload is chosen by preferring an exact match on every argument; failing that, one reachable by widening [VAR-004], since a parameter is an assignment context [VAR-017]. When neither fits, the call fails with No matching signature for function.

So a Char argument selects a Char parameter where one is declared, and widens to a String parameter where it is not.

Selection makes three passes, and the order is the rule: one admitting no widening, then one admitting it, then one admitting absorption [FUN-005]. Adding widening to a single pass let declaration order decide instead — Take('a') took a String overload declared above the Char one — which conformance/0050 caught at once.

The third pass is why "a fixed-arity signature beats a variadic one" is written nowhere. It is the pass order: absorption never runs when either of the first two found something, so Log ('warn', [1, 2]) passes the list rather than gathering it into a second one holding it.

Each pass runs over the whole inheritance chain before the next begins. An exact match on a parent must beat a widened match on the child, or adding an overload to a subclass would silently capture calls the parent was answering exactly.

Inheritance is not widening. A Dog fits an Animal parameter in both passes, because that is the argument being what the parameter asks for rather than being converted into it.

conformance/0137-parameters-match-on-signature.a24

function G (N : Integer); begin Exit 'integer ' + Str (N); end
WriteLn (G (7));

// A parameter is an assignment context [VAR-017], so an argument WIDENS into
// it: an Integer where a Double is written, a Char where a String is.  The
// parameter holds the wider type, so this prints 1.0 rather than 1.
function D (X : Double); begin Exit X; end
WriteLn (D (1));

function S (T : String); begin Exit T + '!'; end
WriteLn (S ('a'));

// The same two widenings at a method, which is where they were already
// admitted at the declaration and refused at the call.
class N;
begin
    function Only (T : String); begin Exit 'string only'; end
end
WriteLn (N ().Only ('a'));

// An EXACT match is preferred over a widened one [EXP-014], whatever order
// the overloads are declared in.  Selection makes two passes for this: one
// admitting no widening, then one admitting it.
class M;
begin
    function Take (T : String); begin Exit 'string'; end
    function Take (C : Char);   begin Exit 'char';   end
end
WriteLn (M ().Take ('a'));
WriteLn (M ().Take ('ab'));

// Inheritance is not widening -- a subclass fits its parent's type in both
// passes, because that is the argument being what the parameter asks for.
class Animal; begin end
class Dog (Animal); begin end
function Feed (A : Animal); begin Exit 'fed'; end
WriteLn (Feed (Dog ()));

Shell

$ algc conformance/0137-parameters-match-on-signature.a24
integer 7
1.0
a!
string only
char
string
fed

9.6 Subscripting

[EXP-015] Subscripting a String yields the Char at that character position, counted from zero [SRC-004]. An index outside the value is Index N out of range 0..M.

conformance/0051-string-subscript.a24

var S := 'abc';

WriteLn (S[0]);
WriteLn (S[2]);
WriteLn (S[0] is Char);

var T := 'café';

WriteLn (T[3]);
WriteLn (T[3] is Char);
WriteLn (Length (T));

// The bound is in characters too, so the last index is 3 and not 4.
try
    WriteLn (T[4]);
except
    on e : String do WriteLn (e);
end

WriteLn (S[9]);

Shell

$ algc conformance/0051-string-subscript.a24
Uncaught: Index 9 out of range 0..2.
a
c
true
é
true
4
Index 4 out of range 0..3.
exit: 70

[EXP-016] A class instance is subscripted through Get and Put — see [TYP-010].

9.7 Assignment

[EXP-017] Assignment is an expression, and its value is the value assigned: X := (Y := 1) leaves both at 1.

conformance/0052-assignment-is-an-expression.a24

var X := 0;
var Y := 0;

X := (Y := 1);

WriteLn (X);
WriteLn (Y);

// So it may appear where a value is wanted.
var Z := 0;
WriteLn ((Z := 5) + 1);
WriteLn (Z);

Shell

$ algc conformance/0052-assignment-is-an-expression.a24
1
1
6
5

10. Statements

10.1 Blocks and expression statements

[STM-001] A block is begin … end and may be empty.

conformance/0053-blocks-and-conditionals.a24

// STM-001: a block may be empty.
begin
end

// STM-003: the condition is tested for TRUTHINESS, not required to be Boolean.
if 1 then WriteLn ('integer 1 is truthy');
if 0 then WriteLn ('not reached'); else WriteLn ('integer 0 is falsey');
if 'text' then WriteLn ('a String is truthy');
if nil then WriteLn ('not reached'); else WriteLn ('nil is falsey');

// STM-004: an else binds to the NEAREST unmatched if.  Were it bound to the
// outer one, nothing would print here.
if True then
    if False then WriteLn ('not reached');
    else WriteLn ('inner-else');

Shell

$ algc conformance/0053-blocks-and-conditionals.a24
integer 1 is truthy
integer 0 is falsey
a String is truthy
nil is falsey
inner-else

[STM-002] A declaration may not stand as the body of a branch or a loop. if C then var X := 1; is refused; the declaration must be inside a block.

It used to be accepted, and the declared name escaped into the enclosing scope — so whether the name existed was decided by a runtime condition, and a loop body never entered behaved the same way.

A declaration stays legal as a try body, which is a statement rather than a branch: try var X := 1; … has to parse.

refusals/0034-declaration-as-an-unbraced-body.a24

if True then var X := 1;

Shell

$ algc refusals/0034-declaration-as-an-unbraced-body.a24
Uncaught: A declaration cannot be a branch or loop body; use 'begin' ... 'end'.
[ERROR] refusals/0034-declaration-as-an-unbraced-body.a24: A declaration cannot be a branch or loop body; use 'begin' ... 'end'.
[ERROR] 1 | if True then var X := 1;
[ERROR]   |              ^^^
exit: 70

10.2 Conditionals

[STM-003] if Cond then S with an optional else S. The condition is tested for truthiness [VAL-008], not required to be a Boolean. A missing then is Expect 'then' after if condition.

[STM-004] An else binds to the nearest unmatched if.

10.3 Loops

[STM-005] while Cond do S. A missing do is Expect 'do' after condition.

conformance/0054-loops.a24

// STM-005: while.
var N := 0;
while N < 3 do
begin
    Write (N);
    N := N + 1;
end
WriteLn ('');

// STM-006: the counted form.
for var I := 0; I < 3; I := I + 1 do Write (I);
WriteLn ('');

// STM-007: for..in over a collection, a String, and a Map.
for var E in [7, 8] do Write (E);
WriteLn ('');

for var C in 'abc' do Write (C);
WriteLn ('');

// Over a Map it yields each KEY, not each value.
for var K in [1 : 'one', 2 : 'two'] do Write (K);
WriteLn ('');

// STM-010: break leaves the innermost enclosing loop.
for var I := 0; I < 10; I := I + 1 do
begin
    if I = 3 then break;
    Write (I);
end
WriteLn ('');

// The INNERMOST one -- the outer loop keeps going.
for var I := 0; I < 3; I := I + 1 do
begin
    for var J := 0; J < 10; J := J + 1 do
    begin
        if J = 1 then break;
        Write (J);
    end
    Write ('|');
end
WriteLn ('');

Shell

$ algc conformance/0054-loops.a24
012
012
78
abc
12
012
0|0|0|

[STM-006] The counted form is for Init ; Cond ; Step do S, and it desugars into a block holding the initializer and a while — which is why its variable is scoped [DCL-008].