2023--: V0.082

2023-04-05: V0.081

Fuzion language
- Introduced syntax sugar for lazy evaluation.
- The code for handling of outer types has been rewritten entirely.
- Parser has been improved to distinguish infix : from : used in inherits clause.
- Support for Multi-line strings literals
- Improved type inference of type parameters, e.g., 3 = f now works for f being of any numeric type, not only for i32.
- Using universe.this.x it is now possible to access a feature named x.
- type features can now access the type parameters of the underlying feature, e.g.,
  
  Sequence (T type) is ... type.empty Sequence T is lists.empty T
- added syntax for effects in feature declarations.
  
  HelloWorls ! io.out is say "HelloWorld!"
base library
- added Mutable_Linked_List and mutable_tree_map
- renamed has_equality as equatable
- lazy variants of some features where removed, the main variants are now lazy
- Unary function type has been introduced.
- Monoid no longer defines its own infix ==, but uses equatable
- time.date_time and time.now were added
- mutate now supports local mutation
- comparable_sequence was merged into searchable_sequence
- CTrie can now be created using a sequence of key-value pairs (#1073)
- uses of stream removed for planned removal of stream feature
- String now supports split_n, split_after, and split_after_n
- list.init was added.
- clean up in fuzion.sys.fileio
- on Windows, stdout and stderr is now opened in binary mode.
- documentation has been improved for many standard library features.
- more consistent naming: string -> String, Object -> Any, or mapOf -> map_of
- equality testing now done using type.equality
- Haskell-style infix : operator for lazy lists was added
- added Sequence.infix [] with no argument, returns a function that takes an index, and returns the element of the sequence at the given index.
- Replaced hasHash, partially_ordered, and orderedby has_hash, has_partial_order, and has_total_order.
fz tool
- quadratic compilation time was improved
- formatting of code in error messages more readable now
- on a call with wrong arg count, error message now proposes solution
- some error messages have been improved.
- output of -XdumpFUIRoption improved for better debugging (#1110)
- fixed many bugs relating to type features
interpreter back-end
- clean-up in handling of open resources like files
C back-end
- windows support for fileio and env vars has been improved (#1087)
fzjava tool
- improved performance by lazily accessing data from dependent .fum files.
fzdocs tool
- now creates links to redefined features
- removed emojis in the page titles, 🎆 (effects) and 🌌 (universe)
- private features are now hidden from the documentation by default.

2023-01-12: V0.080

Fuzion language
- type features can now access the type parameters of the underlying feature.
- Support for covariant feature redefinition:
  
  a.this.type can now be used to refer to the type of an outer feature a. This can be used, e.g., to ensure that an argument or result of a feature has the same type as the target. E.g., numeric.infix + can require the argument and result to be of type numeric.this.type such that in a redefinition i32.infix + requires an argument of pf type i32 and produces a result of the same type.
- Modifiers synchronized, const and leaf or no longer supported (but are still reserved keywords).
- Added modifier fixed for features that should not be inherited by children of the outer feature.
- A type parameter T with constraint c is now declared using T type : c which is in sync with the syntax for feature inheritance x : c is ....
base library
- moved many features from plural-form unit type features to type features, e.g. Sequences.empty is now Sequence.type.empty.
- lots of renaming from camelCase to snake_case as in mapOf -> map_of.
- renamed Object as Any.
- renamed string as String (ref features should start with a capital).
- added type.equality to several features.
- infix ⋃ and infix ⋂ are now used for union and intersection instead of ∪ and ∩.
- unit.type.monoid was added.
- file.io now supports seek and file_position. exists was replaced by stats/lstats.
- String now supports find_last, to_valid_utf8, fields_func, cut.
- Indices in strings are now usually byte indices in the uft8-encoding, e.g., String.substring and String.split now use utf8-byte indices as arguments. Features working on codepoints were renamed for clarity: pad_start as pad_codepoint_start and substring_codepoint.
- list now has features prepend_to_all and intersperse, no longer supports forceHead.
- outcome now is a monad such that verbose match-statements can be replaced by concise calls to bind.
fz tool
- back-end now uses -Wall -Werror by default.
fzjava tool
- improved performance by lazily accessing data from dependent .fum files.

2022-12-08: V0.079

Fuzion language
- An implicit (empty) else-branch in an if-statement now results in 'unit'.
- Inheritance for type features:
  
  Abstract type features using arguments or results of the corresponding type can now be redefined using the actual type. For now (until better syntax is supported) the implicit generic type 'THIS_TYPE' is used in the abstract feature.
- conflicting argument names as in
  
  f(i, i i32) is
  
  now result in an error.
- prefix, postfix and infix operators can now be declared with type parameters and one (prefix, postfix) or two (infix) value arguments:
  
  prefix $$(X type, a X) => "type:{X.name} val:$a"
  
  permits a call '$$x1' if the operator is declared in the current (or outer) feature. Type parameters in this case are inferred from the actual arguments.
- A 'match' statement now may have an empty list of cases
- Syntax improvements in '.type' and '.env' expressions.
- Updated to support Unicode 15.
- Disallow declaration of uninitialized fields as in 'f i32 := ?'.
- tuple types now can use '(A,B,C)' syntax, e.g.,
  
  triple(T type, v T) (T,T,T) is (v,v,v)
  
  is equivalent to
  
  triple(T type, v T) tuple T T T is (v,v,v)
- function types and lambda expressions can no longer be declared using the 'fun' keyword. Instead, syntax like '(i32, bool) -> string' or '(x,y) -> x + y*3' has to be used.
- Fuzion grammar cleanup: new rule 'actual' for actual arguments, which could be an expression for a value argument or a type for a type argument
- cleanup and simplification in indentation rules for actual arguments and cases in a match-expression.
- ASCII control codes 'HT', 'VT', 'FF' and stray 'CR' are now rejected in the source code.
base library
- added effect to new feature 'io.file': 'exists', 'delete', 'move', 'create_dir', 'stat.exists', etc.
- fixed spelling errors, updated syntax for type parameters (comments still used '<'/'>')
- removed 'java' feature and all inner features 'java...', these were unused.
- Fuzion modules now exist for most standard Java modules:
  
  'java.base' 'java.compiler' 'java.datatransfer' 'java.desktop' 'java.instrument' 'java.logging' 'java.management' 'java.management.rmi' 'java.naming' 'java.net.http' 'java.prefs' 'java.rmi' 'java.scripting' 'java.security.jgss' 'java.security.sasl' 'java.se' 'java.smartcardio' 'java.sql' 'java.sql.rowset' 'java.transaction.xa' 'java.xml.crypto' 'java.xml' 'jdk.accessibility' 'jdk.attach' 'jdk.charsets' 'jdk.compiler' 'jdk.crypto.cryptoki' 'jdk.crypto.ec' 'jdk.dynalink' 'jdk.editpad' 'jdk.httpserver' 'jdk.jartool' 'jdk.javadoc' 'jdk.jconsole' 'jdk.jdeps' 'jdk.jdi' 'jdk.jdwp.agent' 'jdk.jfr' 'jdk.jlink' 'jdk.jpackage' 'jdk.jshell' 'jdk.jsobject' 'jdk.jstatd' 'jdk.localedata' 'jdk.management.agent' 'jdk.management' 'jdk.management.jfr' 'jdk.naming.dns' 'jdk.naming.rmi' 'jdk.net' 'jdk.nio.mapmode' 'jdk.sctp' 'jdk.security.auth' 'jdk.security.jgss' 'jdk.xml.dom' 'jdk.zipfs'
- renamed several features from 'camelCase' to 'snake_case' or 'Capitalized_snake_case' for 'ref' types.
- abstract equality (see https://flang.dev/design/equality") as explained by Noble et al in The Left Hand of Equals (http://web.cecs.pdx.edu/~black/publications/egal.pdf) is now supported:
  
  base library feature 'has_equality' defines an abstract feature 'has_equality.type.equality' that can be redefined for heir features such as 'string'. Note that the equality operation is bound to the type, so different types along an inheritance hierarchy may define different equality operations. This is in strong contrast to object-oriented approaches like Java that inherit 'Object.equals'.
  
  For now, features 'equals' and 'infix ≟' can be used to compare according to abstract equality as defined by the operand's type. Eventually, 'infix =' will be used for this.
  
  'type.equality' was defined for base library features without type parameters (type features are not yet supported for features with type parameters)
- Added features to set env variables.
- In some library features, 'forAll' was renamed as 'for_each' to avoid confusion with 'infix ∀'.
- Improved documentation of many features
- added bit-wise-not operation 'prefix ~' to 'wrappingInteger'.
- support for big integers via Fuzion features 'int' and 'uint'.
- 'numericSequence' now inherits from 'hasEquals'
- removed uses of 'stream' from 'string' in favor of 'list'.
- added new module 'terminal.fum' providing ANSI escape codes. The main purpose of this module at this time is to provide a simple test for modules.
- added 'ctrie' hash tries.
- added 'ascii' for ASCII control codes.
- generally replaced generics using '<'/'>' by type parameters.
- improved syntax of type-expressions: Now using '(list i32).type' instead of the awkward 'list i32 .type'. Same for '.env'.
- added 'cache' effect to allow a simple caching of results.
fz tool
- C back-end now provides options '-CC=' and '-CFlags=' to specify C compiler and options to be used.
- arguments following main feature are now passed to Fuzion code via the 'envir.args' effect.
- new option '-moduleDir' to specify where to load modules from.
- added option '-sourceDirs={,..}' to specify where to search for sources. If this option is not provided, the current directory is used to search for source files. Otherwise, the (possibly empty) list of paths provided via this option is used.
- Added option '-saveLib=' to create a module file.
- Removed option '-XsaveBaseLib' and added '-XloadBaseLib=(on|off)' to disable loading of 'base.fum' module which is needed when creating 'base.fum'.
- new option '-XdumpModules={,..}' to print the contents of a loaded module as a colored hex dump with comments.
- Support for several module files. Except for the base module 'base.fum' that does not depend on another module, module support is still incomplete, e.g., modules may not use type features with types from other modules.
fzjava tool
- Now accepts '-modules' and '-moduleDirs' arguments to specify Fuzion modules already generated that a Java module depends on. This avoids repeated declaration of unit-value features for Java packages.

fzdocs tool

has been added to the main Fuzion repository.

C back-end

Fixed use of thread locals on Windows

tests

added 'tests/indentation/indentation' and 'tests/indentation_negative/indentation_negative' to illustrate and check Fuzion's indentation rules for code blocks and arguments.
added several regression tests for bug fixes

Build infrastructure

Some changes to allow building on NixOS

2022-08-15: V0.078

parser
- unified handling of indentation for blocks of statements, actual arguments, match and .. ? .. | .. expressions, etc.
- actual arguments may now be indented and broken into several lines as follows
  
  call_with_four_args arg1 arg2 arg3 arg4
  
  call_with_four_args arg1 arg2 arg3 arg4
  
  call_with_four_args arg1 arg2 arg3 arg4
  
  call_with_four_args arg1 arg2 arg3 arg4
  
  call_with_four_args arg1 arg2 arg3 arg4
  
  call_with_four_args arg1 arg2 arg3 arg4
- fixed several corner cases related to indentation
- Exceptions to single-line expression as in
  
  if expr ? a => true | b => false say "true"
  
  have been removed, now requires parentheses
  
  if (expr ? a => true | b => false) say "true"
- 't.env' and 't.type' expression now permit the type 't' to be in parentheses '(t).env' and '(t).type' such that type parameters can be provided '(list i32).type' or '(cache myType).env'.
- remove support for function types using 'fun' keyword, must use lambda notation such as '(i32, bool) -> string' instead.
base lib
- started adding support for file I/O
- new feature 'ascii' defining ASCII control codes
- removed use of '<'/'>' for generics in favor of new type parameter syntax.
- added 'cache' effect to allow a simple caching of results.
tests
- added positive and negative tests for indentation: 'indentation' and 'indentation_negative', contain many examples of good and bad indentation.

2022-08-03: V0.077

Fuzion language
- added syntax sugar for tuple types like '(i32, list bool)'.
- allowed types to be put in parentheses, i.e., '(stack i32)' is the same as 'stack i32'. Syntax of '.env' and '.type' will require parentheses, i.e., instead of 'stack i32 .type' one will have to write '(stack i32).type' and similarly for '.env'.
- changed parser to allow actual arguments passed to type parameters to be any type, including function types '(i32)->bool' or tuples '(i32, string)'.
- removed support for lambdas using 'fun' keyword, i.e., instead of 'fun (x i32) -> x+x', you have to write 'x -> x+x'. Type inference from a lambda is not possible, though.
- features with empty argument list and a result type that is put in parentheses (usually a tuple) now require an empty argument list '()' since the result type would otherwise be parsed as an argument list.
C backend
- use DFA to remove fields and calls to read (removed) unit type fields
- do not create code for intrinsics that are found to be unreachable during DFA.
DFA
- cleanup and minor enhancements

2022-07-27: V0.076

C backend
- GC support using the Boehm–Demers–Weiser garbage collector. Use '-useGC' option for the 'fz' command.
- result of application-wide data-flow analysis is now used to control code generation resulting in smaller binaries and (usually) faster build time. This can be controlled using 'fz' with option '-Xdfa=(on|off)'.
FUIR
- Added generic abstract interpreter that provides the basic infrastructure for abstract interpretation. This abstract interpreter is used for the C backend and will be used for other backend and static analysis such as data-flow analysis.
- added application-wide data-flow analysis
- 'fz' command has new option '-dfa' that runs DFA analysis as backend. Should be used with '-verbose=' for 'n>0' to get ouput other than just errors.
base lib
- started adding support for file I/O.
- 'mapOf' now can be used with an array of '(key, value)' tuples
- 'asString' on mutable value now calls asString on the value.

2022-07-04: V0.075

C backend
- tail recursive calls are now optimized using a goto to the beginning of the feature's code.
FUIR
- added analysis to detect tail calls and escape analysis for 'this' instance. The analysis results are used for tail recursion optimization in the C backend.
fzjava
- fixed passing of arrays of references when calling Java code from Fuzion features.
throughout
- many bug fixes

2022-05-31: V0.074

Fuzion language
- Overloading with type parameters now works as follows: A feature f with m type parameters and n value parameters can be called with m+n actual arguments (m types and n values) or, if the types can be inferred from the value parameters, with just n actual value arguments.
  
  If an overloaded f with n formal arguments (type or value) exists, a call with n actual arguments will always call this f with n formal arguments.
fz command
- bug fixes for #113, #297, #300
base lib
- some changes towards using type parameter arguments instead of generics using '<' / '>'

2022-05-18: V0.073

Fuzion language
- add support for calling type parameters, i.e., in a feature f(X type), it is now possible to call X as in say X. The result is an instance of feature Type.
- add support to declare inner feature in type feature, e.g.
```
  i32.type.blabla is say "this is blabla in i32.type"
```
- type features now inherit from the type features corresponding to the plain features their corresponding plain feature inherits from.
stdlib
- added fract, floor, ceil to float.
- fixed stream.asList to work if called repeatedly.
- fixed print and println to stdout/stderr to print the whole string atomically at once, i.e., no longer split it up into single characters.
- added io.stdin.
- added Functions.compose.
- added effect mutate. A mutable field f with initial value v can now be created using f := mut v
fum/fuir:
- add support for type parameters in .fum file

2022-04-23: V0.072

Front End
- improved type inference for results of lambdas: Code like
```
  l.map<T> (x -> f x)
```
  no longer need '', i.e.,
```
  l.map (x -> f x)
```
  suffices.
Fuzion language
- Added new expression xyz.type to get access to a unit type value corresponding to type xyz. This is planned to work for type parameters allowing features to be defined for types that can be used in generic code without to have an instance of that type (e.g., to call a constructor for a value).
- type parameters can now be declared with the normal parameters, i.e., instead of
```
  f<A : xyz, B>(v A, w B) is ...
```
  one can write
```
  f(A xyz.type, B type, v A, w B) is ...
```
  also, calls of the form f<T1,T2> a b can now be written f T1 T2 a b.
  
  Type of the form
```
  list<map<string, i32>>
```
  can now be written as
```
  list(map string i32)
```
  The old syntax will eventually be removed.
- match statement now supports matching *, which creates a default branch.
- calls of the form f a,b,c are no longer supported, has be be either f a b c or f(a,b,c).
- full stop can now be used for empty constructors, e.g.
```
  red is
  green is
  blue is
```
  can now be written as
```
  red.
  green.
  blue.
```
  or even
```
  red, green, blue.
```
- syntax sugar for choice: a declaration of a choice had the form
```
  red is
  green is
  blue is
  point(x,y i32) is

  colorOrPoint : choice<red, green, blue, point> is
```
  Now, this can be done using of as follows
```
  colorOrPoint : choice of
    red is
    green is
    blue is
    point(x,y i32) is
```
  or even
```
  colorOrPoint : choice of
    red, green, blue.
    point(x,y i32).
```
stdlib
- result of list T h tis now list<T> which is convenient in declaring lazy lists as in
```
  ones => list 1 ()->ones
```
  for an endless list of 1s.
- added numericSequence and floatSequence with operations like average, std_dev, etc.
- added float.round
- added ctrie data structure
- added Type as parent feature for types.
- added list.flatMap and Sequence.flatMapSequence
- added Sequence.first with default value argument, Sequence.nth to get n-th element. Sequence is not used more often for iteration, replaces 'stream'.
- added string.trimStart and string.trimEnd
- default random provider can now be seeded with an u64 given in env var FUZION_RANDOM_SEED.
- added effects
  - panic
  - exit
  - envi.vars to access environment variables.
  - envi.args to access command line arguments.
  - concur.thread to spawn threads
- joined floats/bitsets/codepoints/matrices.fz into float/bitset/codepoint/matrix.fz. These will eventually be defined in float/bitset/codepoint/matrix.type.
- move sys to fuzion/sys, this is the location for low-level intrinsics
- removed InitArray, no longer needed since we have array syntax sugar [1,2,3].
- rename searchableList as searchableSequence since it is a Sequence.
- added time.nano for short delays and high-res timer, time.duration for time spans
fum/fuir:
- generics are no longer part of the Fuzion module file or the Fuzion intermediate representation. Instead, these are argument features.

2022-04-01: V0.071

Social media
- new Twitter channel @FuzionLang, please follow
Fuzion language
- added support for effects: New expression '.env' permits access to current instance of an effect
- unicode punctuations are now allowed as codepoints within operators
fz
- 'fz -effects main.fz' now performs static analysis on 'main.fz' and prints effects required by this feature.
stdlib
- new effects: io.out, io.err, random, time.nano, state, envir.args, try/raise
- f32/f63 now offer trigonometric functions, exp, log, and squareRoot, constants ℇ, π
- intersection operator added to psSet: infix ⋂
C backend
- support for f32 and f64
flang.dev
tests
- tests on windows now automated using github

2022-02-25: V0.070

fzjava
- fixed name conflicts between Java's String.isBlank/String.split and Fuzion's string.isBlank/String.split.

2022-02-25: V0.069

flang.dev
- design
  - added example for Automatic Monadic Lifting using Knuth's man-or-boy example and a new feature handles that provides a state monad similar to Haskell's IORef.
C backend
- heap allocate value instances that are kept alive through inner instances, fixes segfault in #168.
IR
- added new category of clazz: dynamic outer ref. A value clazz c is a dynamic outer ref if it is referenced from inner clazzes i and there exists heirs of c that may redefine features such that the accesses from i require dynamic binding.
Fuzion language
- added keyword intrinsic_constructor to mark intrinsics that create an instance of their result type. This simplifies static analysis for frequence cases such as fuzion.java.getField0.
- inline arrays now may end with a comma as in
```
  a := [ 1,
         2,
         3,
       ]
```
stdlib
- added Sequence.reduce, string.split, string.isBlank, handles, ...
fuzion.ebnf
- several fixes, cleanup
fz, fzjava
- minor fixes in scripts for issues reported by shellcheck.

2022-02-04: V0.068

fzjava
- fixed generated code to use 'Sequence' instead of 'List', which was renamed a while ago.
stdlib
- lib: Minor improvements used in tutoral at flang.dev:
  - added 'list head tail' as a counterpart to Haskell's 'head : tail' for list creation.
  - added u128.name
  - added strings.fromCodepoints

2022-01-30: V0.067

front end
- speed up by
  - caching results for AbstractType.actualType
  - replaced string comparison in FeatureName.compareTo by int comparison.
  - removed usage of strings in AbstractFeature.isOuterRef
  - removed feature names for internally generated features from .fum file
  - caching for LibraryFeature.innerFeatures()
  - disabled check()s unless env var CHECKS=true
  - removed outer ref field from choice features and from any feature whose outer feature is the universe.
stdlib
- added 'elementOf'/'infix ∈' to 'string'
- added 'add' to 'Set'
- added explanation of the origin of the term 'yak' to the same named feature.

2022-01-24: V0.066

front end:
- speeup up by
  - creating source positions for code loaded from .fum file on demand only.
  - caching of code, result, outerRef withn LibraryFeature
  - using StatementVisitor instead of FeatureVisitor. The former does not support code modification, so it might be faster.

2022-01-21: V0.065

flang.dev
- added .fum file documentation to https://flang.dev/design/fum_file
- added browsable fuzion API documentation to https://flang.dev/docs/index
parser
- single-line operator expressions may now continue after a multi-line klammer-expression, e.g.,
```
  a := 1 * (2
            + 3
            + 4) - 5
```
  is allowed now. The same holds for expressions using [] or {}:
```
  b := 2 * { say "hi"
             + 4
           } - 1

  c := 3 * [ "A",
             "B",
             "C" ].fold strings.concat
                  .byteLength - 5
```
- improve handling of '.'-chained calls over several lines. It is now possible to write
```
  s := myseq.drop n
            .take m
            .asString
```
  before, '.take' was applied to 'n' instead of the result of '.drop'. Now, a space separated argument list is terminated by a new line followed by '.', while a call in a line is permitted to continue in the next line if followed by an indented '.'.
front end
- suppoert for qualified features, even to add inner features to library code such as
```
  i32.factorial => if val <= 1 then 1 else val * (val-1).factorial
```
  or even
```
  i32.postfix ! => if val <= 1 then 1 else val * (val-1).factorial
```
  such that you can write
```
  say 6.factorial
  say 4!
```
- parser now uses the same rule when parsing a .fz file read form a source directory as when reading stdin or an explicit file given on the command line. Before, .fz files read from a source directory were not permitted to contain more than one feature declaration.
- cleanup in module creation and loading code
stdlib
- renamed 'List' as 'Sequence'. A 'Sequence' is a finite or infinite data structure containing elements of one type that can be iterated as a (Lisp-style) 'list' or a (Java-style) 'stream'
- cleanup: joined related source files, e.g. i32.fz now contains the code of i32s.fz and i32_.fz as well. This is possible since .fz files read from a source directory now may contain several feature declarations.

2022-01-06: V0.064

front end:
- several optimizations like caching to improve performance of using module file.
- save source code positions of feature declarations and statements to module file for more detailed error messages.

2022-01-03: V0.063

front end:
- support precompilation of base library code into a module file build/modules/base.fum.
  
  This file is mapped into memory instead of parsing the source files in build/lib resulting in faster startup up.
  
  For the front end and the interpreter, the AST is re-created from this file as needed.
  
  Currently, the AST is also re-created to produce the FUIR representation used by the C backend, but this should eventually not be needed any longer.

2021-10-29: V0.062

flang.dev website
- added more idioms, e.g. #182 (quine), 242..258, etc.
IR
- major code restructuring and cleanup moving logic away from the AST and into the Front End, Middle End, Application IR, etc. The goal is to be able to create "module IR" files as a faster replacement of source code.
- added very basic data-flow-analysis phase that finds some very obvious cases of uses of uninitialized fields.

2021-10-15: V0.061

flang.dev website
- added many idioms, updated syntax of existing idioms
library
- added matrix, matrices
- lot's of minor improvements
Frontend
- improve type inference for type parameters
general
- switched to OpenJDK 17

2021-09-30: V0.060

flang.dev website
- new design for code input / execution output text areas
- tuturial section on string literals.
- examples and idioms updated for new syntax of lambda expressions and function types.
- new idioms 141, 142, 150
fuzion.ebnf
- grammar is now checked using antlr, bugs and inconsitencies have been fixed.
Frontend/Parser:
- new syntax for function types: '(i32, string) -> bool' or 'u8 -> string'
- new syntax and type inference for lambdas: 'x -> 2*x', 'x,y -> x+y', '(a,b,c) -> a < b < c', '() -> 42', etc.
- last expression in a constructor now must result in type 'unit'. This is to find problems earlier when constructors are used instead of routines.
IR
- removed callbacks from IR to the backend to have a clearer separation of phases.
FUIR
- Moved code to set outer references from backend to FUIR to simplify backend.
C backend
- fix wrap-around overflow handling in created code for signed integer types.
- several code generation fixes
- code cleanup
tests
- analyzed root cause of failing tests, added issues to github for tests that could not be fixed, added mechanism to skip these tests, such that a normal build does not report any errors for known problems.
fz
- limit number of errors and warnings printed, new options '-XmaxErrors=' and '-XmaxWarnings='.
- many bug fixes

2021-09-02: V0.059

FrontEnd / lib / backends
- support for types i8, i16, u8, u16, f32, f64.
flang.dev website
- added sections on integer and float constants to tutorial.
Java interface:
- added java.desktop module that contains java.awt graphics
- support for primitive types and Java arrays
examples
- added example javaGraphics that uses java.desktop module to draw into a window.

2021-08-23: V0.058

FrontEnd
- fix running examples such as tutorial/overflow* on flang.dev (see git commit for details).

2021-08-20: V0.057

Java interface
- new tool fzjava to create Fuzion wrappers for Java code
- 'fz -modules=java.base ' will run '' with JDK's java.base module accessible, e.g., via
  
  serversocket := Java.java.net.ServerSocket.new 8080
examples
- added example 'callingJava' to show how to call Java code from Fuzion and 'webserver' that shows how to use Java APIs to write a minimalistic web server in Fuzion.
fz
- now supports modules via '-modules' options. Currently, these are just additional source code directories in 'build/modules', but these should be packed into fuzion module files eventualls.
Parser
- precedence of fraction bar ⁄ is higher than basic arithmetic operations.
library
- support for types i8, i16, u8, u16
- string.utf8 now returns an List.
flang.dev website
- now supportes ACE editor for source code
- use server-side events to fix many issues in the communication.
- several new idioms implemented and old ones improved
General
- Fuzion logo is now generated

2021-07-30: V0.056

Parser
- Changed parsing of expressions using []: 'a[i]' is an call to 'a.index ' as before, but 'a [i]' now is a call to 'a' with an array as argument, i.e., 'a([i])'. This avoids extra parentheses when passing an array as an argument.
tests
- changed syntax in tests to not use { }, ( ), commas, semicolons, when possible
fz
- now accepts '.fuzion' as extension for source file given as command line argument: 'fz ./helloworld.fuzion' now works instead of printing a confusing message.
- error messages now enclose code snippets in '' and highlight feature names, types and expressions in different colors.

2021-07-21: V0.055

C backend
- several bugs fixed: bugs related to (normlized) outer refs, calls to not-instantiated clazzes, code after a statement that produced a void result, array of unit type, etc.
IR
- several fixes in normlization of outer refs, i.e., in the way clazzes instantiated with different outer contexts are distinguished. This fixed several tests that failed when using the C backend.

2021-07-08: V0.054

flang.dev
- changed path to load 'main.js' to be absolute '/main.js'. Before, main.js could not be loaded if the first page access was in a sub directory such as 'flang.dev/tutorial/index' and anything requiring java script, like executing examples, did not work.
Front End
- fixed issue#8: returing 'false' as 'option' n logner allowed

2021-07-06: V0.053

Parser

More haskell-style call syntax

  f(a,b)   calls f with arguments 'a', 'b'
  f (a,b)  calls f with argument '(a,b)', a tuple

  f fun () => x    no longer works
  f (fun () => x)  must be used instead

Front End
- Now enforce feature with 'unit' result to result in unit type value.
lib
- faction now uses unicode fraction slash '⁄' to create fraction, e.g., '1⁄2'

2021-06-30: V0.052

Parser
- Haskell-style call syntax with space separated arguments and left binding, so the call
```
  f a b (g c d)
```
  is equivalent to
```
  f(a,b,g(c,d))
```
  Additionally, infix, prefix and postfix operators now bind stronger than a call if there is no white space (or comment) between the operator and its operand, and weaker than a call if there is white space. This means
```
  f x+1
```
  is equivalent to
```
  f(x+1)
```
  while
```
  f x + 1
```
  is equivalent to
```
  f(x)+1
```
  This makes the semantics depend on white space in a way that might be surprising. This change is therefore considered for experiments only, if this turns out to be too confusing, the grammar should go back to not make operator precedence depend on spaces around operators.
lib, tests
- libs and tests were changed to support new call syntax, in particular the left binding of call and the weaker precedence of operators that are separated by white space.

2021-06-29: V0.051

flang.dev
- design: added flang.dev/design/calls.html for thoughts on Fuzion's call syntax.
- added idioms 134, 135, 136
front end
- allow chained boolean expressions with >3 terms, e.g., 'a < b < c < d'
- support for '? |' instead of match, allow '|' as case separator
```
  a ? x X => x.foo
    | y Y => y.bar
```
  as short-hand for
```
 match a
   x X => x.foo
   y Y => y.bar
```
  also allowed is
```
 match a
   | x X => x.foo
   | y Y => y.bar
```
- A loop's 'until' clause now supports 'then' to separate the condition from the code executed for successful loop termination. The code is now summetric to 'if cond then'.
lib
- 'o??' and 'o!!' are new postfix operator synonymes for 'exists' and 'isNil' in 'option', 'numOption' and 'outcome'.
fz
- several bug fixes in FE, IR, FUIR; interpreter and C backend.

2021-06-23: V0.050

Fuzion front-end/middle-end
- Fixed major performance bottleneck, performance improved by about 40-60%.
fz tool
- new option -XjavaProf (for profiling fz's own Java code) and -X/--xhelp).
flang.dev
- added idiom 76

2021-06-22: V0.049

lib: added
- bitsets
- sum
- List.tails, takeWhile, dropWhile
- searchableList.countMatches, countMatchesOverlapping
- string.count, contains
FUIR
- suppress code generation for pre- and post-conditions that are constant and 'true'. Reduces binary size when using C backend on HelloWorld with '-debug=0 -safety=off' by 3.5%.
flang.dev
- added idioms 39, 40, 49, 68, 76, 82, 116

2021-06-18: V0.048

IR: Added mechanism to 'normalize' clazzes to reduce the explosion in the total number of clazzes generated: Clazzes that only differ in their outer clazzes are now fused if the outer clazzes are references.
lib
- replaced 'streamable' by 'List', i.e., the preferred way to iterate is by using lisp-syle lists consisting of a head and a cons-cell.
- added u128 for unsigned 128-bit integers
flang.dev
- added idioms 62, 63

2021-05-31: V0.047

tools:
- fz tool now prints execution time for phases prep, front end, middle end, ir, and back end.
front end:
- improved performance by caching result of Type.outer()
lib
- fix exponential performance when printing string built from s+(s+(s+(...)))

2021-05-30: V0.046

lib
- string: added startsWith, endsWith
flang.dev
- added idioms 84, 85, 86, 87, 88, 89, 90, 93, 96, 97, 100, 108, 110, 112, 113, 114, 117, 118, 119, 122, 124, 127, 227, 231

2021-05-24: V0.045

lib:
- integer.bin/cot/hex to create binary, octal and hex strings
- fix quadratic runtime of printing string consisting of many sub-strings concatenated using 'infix +'.
- i32/u32/i64/u64: added ones_count (population count)
- stream/streamable: added asList, planning to work more with (lazy, immutable) lists than with streams that are inherently mutable. Also added 'take', 'drop', 'infix ++' and 'asArray' to stream/streamable.
- added feature 'some' as standard wrapper. This can be used, e.g., to make an 'option<some>' without getting complaints about overlapping values, the possible values of typ 'option<some>' are 'nil' and 'some nil'
flang.dev
- added idioms # 38, 44, 46, 47, 48, 53, 54, 55, 57

2021-05-24: V0.044

lib
- new unit types strings, i32s, i64s, u32s, u64s that contain monoids and other features related to string, i32, i64, u32, u64 but not requiring an instance. Also added new routines i32, i64, u32, u64, all without arguments to distinguish them from the integer types that have one argument, that result in the corresponding unit type i32s, i64s, u32s, and u64s, respectively.
  
  Now, we can write, e.g., '[1,2,3].fold i32.sum' to sum the elements of an array.
- add new feature 'Set' as abstract parent for sets, and operations such as 'infix ∈', so we can write '2 ∈ [1,2,3]' or '7 ∉ 10..300' (both result in bool value true).
flang.dev
- added idioms # 51, 52

2021-05-21: V0.043

lib
- added codepoint.fz and string.codepoints/codepointsArray to create stream and array of codepoints from a string.
- added 'infix **' for integer exponentiation.
parser/lexer:
- support for binary, octal, and hex numbers using prefix 0b, 0o, and 0x. Support for grouping of digits using '_' as in 'ichiOku := 1_0000_0000', groups must be equal in size and at least two digits long.
flang.dev
- added idioms # 32, 41
- added design page on integer literals / constants.

2021-05-20: V0.042

lib
- add string.parseI32*, parseU32*, etc to parse integers from decimal, binary, octal or hex numbers. Very nice generic implementation for all integers in one feature!
- added error.fz for an error condition
- added outcome.fz similar to Rust's result: a choice between a value and an error.
flang.dev
- added idioms # 18, 22, 26, 27, 34, 42

2021-05-19: V0.041

flang.dev
- added idioms # 8, 9, 13, 16, 19
lib
- added array.reverse, list.reverse
- added fuzion.std.panic
- added map as parent of hashMap and orderedMap, defines keys, values, items
- added Option/array/list.asString
front end
- fix#9: AdrToValue.type() was not intern()ed.

2021-05-18: V0.040

-lib

added features partiallyOrdered and ordered and implemented ordered by numeric and string.
added feature hasHash and implemented it for numeric and string.
added hashmap and orderedMap.
added psMap and psSet to have well behaved persistent sets and maps for ordered values.
added highestOneBit and trailingZeros to i32/i64/u32/u64
C backend
- add support for indentation in generated code.

2021-04-20: V0.039

C backend
- now works with array initialization using '[a, b, c]'.
flang.dev
- updated examples to use array initialization instead of InitArray.fz
- new design of main page using CSS magic.

2021-04-20: V0.038

Fuzion language
- Support for array initialization using '[a, b, c]' or '[e; f; g]' where the array elements are expressions. The array type is either inferred from the union of the types of the element expressions or propagated back from the target the array is assigned to. Boxing and Tagging for array elements is automatic. Support in FUIR/C backend missing, only interpreter for now.

2021-04-14: V0.037

Fuzion language
- match statement:
- now infers actual generics if this does not lead to ambiguity. So one can, e.g., match a 'list' against 'Cons' instead of 'Cons<string, list>'.
- Errors are created if a case does not match anything, matches several types or if some cases are missing
lib
- bitset.fz provides persistent bitsets
- array.fz is a persistent array now, i.e., array.put(index, value) creates a new array.
- stream.map, stream.fold added
- numeric.min, numeric.max added

2021-04-08: V0.036

lib
- array.fz is immutable now, new feature marray.fz provides mutable arrays.
Fuzion Language:
- Field initialization 'f type := value', instance decomposition '(a i32, b bool) := obj' and array writes 'a[i] := v' now use ':=' instead of '='.

2021-04-07: V0.035

Fuzion Language:
- Assignments are no longer accepted in the format 'a = b'. Instead, an assignment must be of the form
  
  set a := b
  
  to make sure that mutations are clearly visible in the source code.

2021-04-06: V0.034

Fuzion Language
- identifiers now may consist of non-ASCII code points of Unicode categories LC, Ll, Lm, Lo, Lt, Lu, Nd, Nl, and No, while the first character may not be of one of the numeric types No, Nl, No.
- operartors now may consist of non-ASCII code points of Unicode categories Sc, Sk, Sm, So.
tools:
- fz tool now supports command line options -verbose, -debug, -safety, -unsafeIntrinsics
- 'fz' now can be used giving a source file name as in 'fz Hello.fz'.
- 'fz -latex' creates a LaTeX style for Fuzion source code.

2021-03-29: V0.033

lib
- added list.fold, list.take, added predefined monoids to numeric ands string.
- renamed FALSE.fz and TRUE.fz to avoid name clashes on case-insensitive file systems.

2021-03-25: V0.032

Fuzion Language:
- Constant string now allow embedded identifiers using $id and embedded expressions using {expr}.
- Constant strings now support escape sequences:
  
  Esc sequence result unicode
  
  '\b' BS 0x08
  
  '\t' HT 0x09
  
  '\n' LF 0x0a
  
  '\f' FF 0x0c
  
  '\r' CR 0x0d
  
  '"' " 0x22
  
  '$' $ 0x24
  
  ''' ' 0x27
  
  '\' \ 0x5c
  
  '{' { 0x7b
  
  '}' } 0x7d

2021-03-19: V0.031

C backend
- function to compile one whole feature is pure now
tests
- Makefiles now run tests using c backend in addition to interpreter

2021-03-18: V0.030

C backend
- support for postconditions

2021-03-17: V0.029

C backend
- support for choice types of unit types and one reference type, (e.g., Option). These do not require a tag since the unit types can be encoded as a special pointer value.
- support for preconditions

2021-03-16: V0.028

AST/IR/BE:
- Tagging a value when assigned to a choice type is now done explicitly by an IR command Tag. This no longer happens implicitly as part of an assignment, simplifying the IR and backends.
C backend
- fix handling of boxed unit
Parser
- a field with formal generics or formal arguments is now disallowed as early as during the parsing step.

2021-03-15: V0.027

IR
- now distinguishes instantiated from called clazzes resulting in less code generated by C backend
C backend
- support for arrays of arbitrary types
- support for fields declared in universe

2021-03-11: V0.026

C backend:
- loads of clean-up and simplifications
- bug fixes for dynamic calls and write accesses to outer fields

2021-03-10: V0.025

C backend:
- implemented match for non-ref values (i.e, values that distinguished by tag and not by a type check).
Benchmarks:
- added c_man_or_boy, a benchmark that compiles a the man_or_boy example to C

2021-03-09: V0.024

Desgn:
- Added section "Automatic global data" in the file design/monadic_lifting.html to propose monadic parameters together with automatic monadic lifting of callers of features with these monadic parameters as a solution for global state (and much more).
C backend:
- Choice types make progress: C structs defined, assignment to choice type is implemented, match statement is still missing.
- fixed dynamic calls that did not work to call inherited feature.

2021-03-05: V0.023

Design
- added 'Feature Kinds' section with very detailed comparison of the capabilities of constructors, routines, fields, intrinsics, abstracts and choices. Includes example code for uses of each feature kind in different scenarios.
C backend:
- several bug fixes and improvements.

2021-03-02: V0.022

C backend
- Compiles and runs HelloWorld without any warnings during Fuzion to C compilation and during C to machine code compilation.
- added intrinsics for i32, i64, u32, u64.
IR/FUIR/C backend:
- code cleanup

2021-02-24: V0.021

IR:
- no longer creates 'impossible' clazzes such as integer.infix + when there is no instance of integer created anywhere. So C backend does not need to filter these out.
- some normalization of clazzes to reduce total number of clazzes and amount of code.
lib:
- monad.fz added for experiments.

2021-02-22: V0.020

lib:
- choice.fz now comes with detailed explanation of sum types
- Tuple.fz now comes with a detailed explanation of product types.
- new list.fz and Cons.fz provide abstract list framework
ir:
- removed several ways that clazzes that cannot exists at runtime such as could be created, e.g., 'integer.ref decimalStr', which should be 'i32.ref deciamStr'.

2021-02-18: V0.019

lib:
- added unit.fz as a standard unit type and changed void.fz into a 'real' void type with no instances.
- added monoid.fz and quantors.fz
- added monadic 'bind' operators to Option and numOption, re-implemented numOption using monads.
front end:
- added boxing of values of generic type and for implicit assignments to function result field.
- internal cleanup with respect to types, removed internally used type t_ANY, replaced it by void.

2021-02-12: V0.018

C backend:
- The C backend successfully compiles a "HelloWorld" example now using the call
  
  fz -c HelloWorld
  
  which generates a HelloWorld.c file and then invokes clang -O3 to create a HelloWorld binary.

Benchmarks:

added c_hello, a benchmark that compiles a HelloWorld example to C

2021-02-07: V0.017

Frotend:
- Inspired by FOSDEM talks on Raku, I have decided to experiment with making the parentheses on calls optional. This means that instead of
  
  f(a, g(h(-b, c + d)))
  
  you can now write
  
  f a, g h -b, c + d
  
  To avoid ambiguity, a new keyword 'then' separates the condition in a single-line 'if'-statement from the following block and uninitialized fields can no longer be declared as
  
  f type
  
  but usng
  
  f type = ?
  
  An operator '' in an expression like 'x y' is now parsed as a prefix operator 'x(y)' if there is white space or a comment between 'x' and '' and no white space nor a comment between '' and 'y', i.e, 'a-b', 'a- b' and 'a - b' are all calling an 'infix -' on 'a' with argument 'b', while 'a -b' calls 'prefix -' on 'b' and passes the result as first argument to 'a'.
stdlib: new features

'say' as shorthand for 'stdout.println'

'integer.infix %%' to check if an integer is divisibly by another integer
Tools
- added simple syntax highlighting tool via 'fz -pretty'
FUIR and C backend
- lots of minor improvements

2021-02-01: V0.016

Frontend:
- all loops are now implemented using tail recursive features. IR and backend support for loops has been removed.
- fixed several problems with field visibility and masking in nested scopes.
Interpreter
- stack trace printing now compresses simple recursion.
C backend
- can compile simple tests including loops now. Main missing features is references and dynamic binding
- made code more readable by using identifiers closer to the original Fuzion feature names.
General
- error printing now uses ANSI escapes to produce colourful output. Can be disabled via env var FUZION_DISABLE_ANSI_ESCAPES=true.
Design
- added page on static vs. dynamic typing

2021-01-12: V0.015

Fuzion IR
- extracted dynamic binding related code from Clazz.java to DynamicBinging.java.
flang.dev
- Removed access restrictions, made website and tutorial accessible without login.
- Replaced Fusion by Fuzion at most locations.
Design
- Updated module dependencies with explicit backends, added dependency from optimizer to interpreter backend since the optimizer will need an engine to evaluate compile time constants and the interpreter should do a perfect job here.
Fuzion Front End
- Removed Loop from AST, a loop is now directly replaced by a tail recurive call.
- Source file name extension is .fz now.
- one line comments introduced with '#' can start in any column now. Replaced '//' by '#' in the standard lib and examples.
C backend
- Compiles and runs first micro-HelloWorld, still many limitations.
  
  hw is fusion.std.out.write(72) fusion.std.out.write(87) fusion.std.out.write(10)
Fusion tools
- added proper command line handling to fusion command line tool, in particular -interpreter, -c, -llvm, etc. to chose backend.

2020-11-22: V0.014

Fusion Middle End
- improved smart linking: Do not include features that could be called dynamically but there is no corresponding dynamic call.
Fusion Front End
- replaced boolean prefix !, infix &&, infix || and infix : by corresponding if-statements to support lazy evaluation.
- implemented simple constant propagation for bool constants.
- Expressions of the form 'a b c' where 'a b' yields a bool result and '' is not defined as an infix operator on bool are now automatically converted to '(a { tmp := b; tmp }) && (tmp c'. This means that expressions such as '0 <= index < length' are now possible.
- Renamed bool operator '==' as '<=>' to avoid confusion when comparing 3 bool variables using 'a == b == c' (which holds, e.g., for 'true == false == false'). Maybe the front end should require parentheses as in '(a <=> b) <=> c' or '(a == b) == c' when 'a' is boolean to avoid confusion. How is this done in other languages?
Fusion tools
- changed fusion.verbose property from boolean to integer, 0 is non-verbose, levels 1..10 show different levels of detail.
- new properties fusion.debugLevel= and fusion.safety= can be used to set the default values for debugLevel and safety (to enable or disable pre- and postcondition checks).
tests
- added test case redef_args to redefine argument fields. Not working yet.

2020-11-16: V0.013

Fusion Interpreter: No longer uses virtual call for a dynamic feature called on a value instance.
middle end: Split up finding runtime clazzes and building virtual call tables into two phases. No longer builds virtual call tables for value clazzes.
Design
- added page "Matches in Expressions" describing possible syntax of expressions using '?' to match the type of a value of choice type.
removed "throws" keyword and its uses in feature declarations and pre/postconditions.

2020-11-13: V0.012

Fusion Interpreter
- fixed boxing of choice types (only the tag was copied, so values remained uninitialized).
standard lib
- added support for 2- and 3-dimensional arrays through features
```
  array<T>>(l1, l2,     fun (i32, i32, i32) T)
  array<T>>(l1, l2, l3, fun (i32, i32, i32) T)
```
  these inherit from the 1-dimensional array feature, so it maps the multi-dimensional array to a flat unidimensional array.
- added feature numOption as a pseudo-numeric result type of numeric's +?, -? and *? operations to allow expressions such as 'a *? b +? c'
- moved code to create interval from i32/i64/u32/u64 into separate generic feature hasInterval to avoid code duplication.
Fusion middle end: Major cleanup and some bugfixes in handling of outer features that showed up when writing hasInterval.

2020-11-10: V0.011

website
- added tutorial pages on integer type, overflows, fractions.
Fusion Interpreter
- now catches StackOverflowError and shows fusion stack trace instead of Java stack trace
Added prefix $ as an alternative to .asString. Now, you can write '$length + "cm"' to create a string like "23cm".
added overflowing, optional, saturating and wrapping basic operations to integer types:
- , - , * cause runtime error (if debug enabled) on overflow / underflow +? , -? , *? produce an Option that is nil in case of overflow / underflow +^ , -^ , *^ are saturating, result is max / min on overflow / underflow +° , -° , *° are wrapping, like in Java
Nice exercise in generic programming: Added asString feature to integer to replace specific implementation in heirs i32, u32, i64 and u64.
operator precedence: Now, prefix operators always take precedence over infix operators, i.e., 'a + + b' is parsed as 'a + (+ b)'. Precedence is taken into account, i.e. 'a * + * b' is parsed as '(a ) + ( b)', while 'a + * + b' is parsed as 'a + (* (+ b))'. Infix operators are parsed left-to-right except for operators with right associativity (currently only '^'). Postfix operators have precedence over prefix operators with equal precedence value, i.e, '+a-' is parsed as '+(a-)'.

The precedence of multi-character operators such as '|-*-|' is determined by the first character, '|' in this case. Precedence levels currently are

15: @ 14: ^ 13: !$ (only prefix and postfix) 12: ~ 11: */%⊛⊗⊘⦸⊝⊚⊙⦾⦿⦸⨸⨁⨂⨷ 10: +-⊕⊖ 9: . 8: # 7: $ (only infix) 6: 5: <>=⧁⧀⊜⩹⩺⩹⩺⩻⩼⩽⩾⩿⪀⪁⪂⪃⪄⪅⪆⪇⪈⪉⪊⪋⪌⪍⪎⪏⪐⪑⪒⪓⪔⪕⪖⪗⪘⪙⪚⪛⪜⪝⪞⪟⪠⪡⪢⪤⪥⪦⪧⪨⪩⪪⪫⪬⪭⪮⪯⪰⪱⪲⪴⪵⪶⪷⪸⪹⪺⪻⪼⫷⫸⫹⫺ ! (only infix) 4: & 3: |⦶⦷ 2: ∀ 1: ∃ 0: all other operators -1: :

this list is a little arbitrary, is there some mathematical precedence definition related to the mathematical unicode chars?
added new keyword "redef" as alternative to "redefine" (will eventually dump 'redefine'.
Fusion std library: Added abstract features numeric and integer as parents for integer types. For integer types i32, u32, i64, u64 added preconditions to catch overflows. Added fraction type: 'a /-/ b' for a, b of any (but the same) integer type defines a fraction that can be used with all the standard operations defined for numeric types.
Enabled support for generic constraints. A generic feature declared as "name(args ..)" puts the constraint c on the generic argument T. NYI: Still need to check that the actual generic arg is assignable to the constraint.
'°' is now a legal character in an operator. New operators +°, -° and *° implement wrap-around operations, while +, - and * have preconditions that ensure there is no overflow.
Created Slack channel #fusion-language: https://join.slack.com/t/fusion-zentrale/shared_invite/zt-j9ab7feo-3fl2oZLBfnKdyfOaDgvnjg
Added types i64, u32, u64 and numeric, made i32, i64, u32 and u64 inherit from numeric.
Removed "throws" clause from the syntax of feature and function declaration, I do not intend to support exception: An exception must either be part of the function result, so it should go there, or it is a fatal error that kills (at least) the current thread.
Fusion Interpreter
- added specialization for reading fields in value type to improve performance

2020-11-06: V0.010

benchmarks: Added first simple performance benchmark that runs the man_or_boy example repeatedly.
replaced abstract and native modifiers by specific routine bodies "is abstract" and "is intrinsic". This avoids the problem of marking a field abstract or intrinsic.
website
- update tools module design (dependency graph)
Fusion Interpreter
- split code into two packages dev.flang.ast and dev.flang.be.interpreter. Removed dependencies from ast to be.interpreter, the dependencies from be.interpreter to ast will have to be changed to refer to fuir (once it exists.

2020-11-03: V0.009

website
- added Fusion grammer fusion.ebnf linked from the main page.
- Fusion Tutorial
  - added sections on Design by Contract, developing with pre- and postconditions, predefined pre- and postcondition qualifiers.
pre- and postconditions for single features are supported now. A failing condition causes termination of the Fusion interpreter with an error message and a (Fusion!) call stack.
Condition qualifiers have been added to control execution of pre- and postconditions: safety, debug, debug(i32), pedantic, analysis.
new boolean operator "infix :", which implements "implies" ((a : b) <==> !a || b). ':' has lowest precedence now, such that preconditions of the form

pre safety: index < length

are possible now.
new keywords "pre", "post", and "inv" as alternatives for "require", "ensure", and "invariant". The latter might get retired soon.
i32.infix / and i32.infix % now check that other != 0 via a pre-condition qualified with safety.
new fields i32.max and i32.min to get the max/min value an i32 can hold. A bit strange: Since i32 is a value type, we need an i32 to get the constant maximum value, e.g., 0.max == i32(-123).max == array.length.max.
inline functions (lambdas declared with "fun (args) ...") now use the same syntax for their implementation as routine definititions: "is" block, "=>" block or a block enclosed in { }.

2020-11-01: V0.008

website
- Added "How to Support Fusion" page.
- Added Rosetta Code Fibonacci example, updated other Rosetta Code examples to use indentation based blocks.
- updated the idioms to use indentation instead of { }.
Fusion language
- ifstmnt and loop are expr now, not stmnt. This means they can be used directly as expressions, it is no longer needed to put them into { } to use them as a value.
- added else and until as block ending tokens such that single line blocks that end with else or until no longer need to be enclosed in { }.
Fusion Front End
- Removed redundent directory listing in source dirs to improve speed.

2020-10-29: V0.007

scopes for match cases: features declared in match cases are now visible only in the match case they were declared in. In particular, the same variable name can be reused for the value we are matching.
Fusion Tutorial
- updated the examples in the tutorial to use indentation instead of { } whenever possible. Added a copy of the tutorial with the original examples as "Fusion Tutorial using { }", linked from the main page.
blocks no longer need to be enclosed by { }. Routine declarations without { } require the new keyword 'is' before their code block.
match statement no longer needs to be enclosed by { }. The right side of a case in a match statement is no longer an expr, but a block. Cases are no longer separated by comma, but by semicolons or flat line breaks. This means that { } are no longer needed if line breaks and proper indentation is used. Single-line match clauses are a bit awkward, though, requiring { } and ';':

v := match x a => { p; q }; b => { r; s }

is equivalent to

v := match x a => p; q b => r; s

is equivalent to

v := match x a => p q b => r s
expressions
- expressions are now restricted to a single line with the following exceptions:
  - an expression within parentheses ( ) or crochets [ ] may extend over several lines
  - a statement sequence within braces { } used as an expression may extend over several lines
  - a dot expression abc.def can have a line break before the dot.
semicolons
- semicolons between statements are now required for subsequent statements in the same block if they are in the same source line, semicolons are optional if statements are separated by a flat line break.
Fusion design pages
- Added much more detail to Blocks and Indentation page
- Added page to Fusion toolchain modules
Fusion Interpreter
- improved performance by
  - caching interned types
  - checking and caching which types do not depend on generics, such that their actual type is always the same.
  - disabling pre- and postconditions in production (enabled by setting env variables PRECONDTIONS=true and POSCONDITIONS=true)

2020-10-22: V0.006

feature declarations and visibility
- field declarations using := can now mask previously declared fields with the same name.
- features in unqualified accesses are now searched taking the scope visibility into account.
a.b.this expression now produces a proper error message if a.b is not found.
Fusion Interpreter
- When processing input from stdin (which is used when clicking "run" on the website examplex), the interpreter now parses stmnts and not feature. If input is a single statement that is a feature declaration, that feature will be executed as before. Otherwise, these statements will be added to the internal feature --universe-- and this will be executed. This has the effect that many small examples no longer need a surrounding feature, e.g., 'stdout.println("Hello, World!")' can be executed directly now and Fusion scripts with shebang are possible.
- uninitialized non-ref values are not initialzed with -555555555 to be more obvious when used. DFA to detect possible uninitialized accesses is still not supported.
Fusion design pages
- Added page on visibility.
- Extended page on strings with section on text blocks and converted it from wiki to html.
- added sections on coroutines, light-weight threading, SIMD and fuom, the Fusion Optimizer.
Loops

Slight change in semantics: 'for i := do .. ' is now interpreted as "for i := , do .. ' and it is not allowed to assign a value to i anywhere else. This allows the following pattern

for data := read() while data >= 0 { process(data) }
comments
- New type of comments enabled: '#' as first codePoint in a line starts a comment that extends to the end of this line. Now we can run fusion codes like scripts by starting the file with shebang, e.g.,
  
  #!/bin/fusion.sh
  
  stdout.println("Hello, World!");
  
  if fusion.sh starts the fusion interpreter.
- Fixed bug in Lexer that disallowed '/' in operators. Now, operators such as infix -/^-^/- are allowed, this does not contain a comment.
Errors
- In case of compilation errors, suppress certain subsequent errors:
  - wrong type if if/while/until expression if type is t_ERROR,
  - missing result type in field declaration if field name is Lexer.ERROR_STRING (indicating a parsing error),
  - expected EOF in case of previous errors

2020-10-14: V0.005

Benchmarks
- added simple infrastructure for daily run benchmarks, accessible through the website. There is currently no dedicated server to run the benchmarks, so there will be jitter, but this should do for now.
Fusion Interpreter
- Added checks that the main feature is not a field, is not abstract, not native and not generic such that this produces a proper error message instead of a Java exception.
Fusion frontend
- overloading for features:
  
  A feature may now be overloaded in the number (not the type!) of its arguments. In particular, there are two features stdout.println now, one with no argument and one that expects a ref Object argument.
  
  This change also added infrastructure that will be needed for Eiffel-style renaming of inherited features.
- initial assignments to fields are no longer allowed unless the field is declared within the code of an outer routine. In particular, x := does not work. This code was never executed anyway and I do not want to leave the execution order as a arbitray decision of the implementation.
Fusion library
- renamed 'fusion.std.out.printline' as 'println', overloading the existing 'println(ref Object)'.
- In 'i32.infix..': Added feature 'lower' and renamed 'other' as 'upper' for convenience. Extended 'infix :' to support negative steps to iterate from 'lower' down to 'upper' (i.e, it requires 'lower >= upper'), e.g., '10..0 : -1' counts from 10 down to 0.
- added 'string.infix *' to repeat a string a given number of times.
Fusion design pages
- added page on blocks using braces vs. indentation
- added page on semicolon and how and when it could be made optional
- changed overloading page from wiki markup to html and added section on argument count overloading.
- changed inheritance page from wiki markup to html and added section on multiple inheritance, conflicts during inheritance and possible solutions to resolve these conflicts.
- added page on assignment syntax
- added page on file name extensions
webserver
- improved logging

2020-10-05: V0.004

lexer
- fixed crash when comment following >>//<< ends with end-of-file instead of new line.
webserver
- added more examples to idioms 1, 12, 17, 20, 21, changed getRed into just red in the tutorial's match examples (Java's getter/setter frenzy apparently found its way deep into my unconsciousness).
- removed user ids for logged in users, they are not needed.
lib
- removed Null.fu

2020-10-02: V0.003

webserver
- added pages to implement the idioms from programming-idioms.org
- index.html template: Added 3sec timeout to reconnect EventSource in case no server response was encountered. This seamms to work better than the previous solution of reconnecting if more than 3 requests were left without reply, but I am still unhappy about this manual reconnect.
loops
- if a loop that may succeed or fail has a VOID result type is used as an expression and type propagation asks it to be of type boolean, then the loop will result in true on successful termination (until condition is true) or false (otherwise: iteration was exhaustive or while condition is false).
- index Vars now may be updated in the loop body if their declaration in the for-clause does not define a value for the next iteration.
- added compiler checks that while- and until-conditions are actually boolean, so we now get a compile-time error instead of a runtime crash
- added type propagation: The while- and until-conditions are expected to be of type bool.
if statement
- added compiler checks that if-conditions are actually boolean, so we now get a compile-time error instead of a runtime crash
- added type propagation: The condition of an if-statement is expected to be of type bool.
compile time errors
- the front end no longer stops after a phase has shown errors but tries to continue until it would execute the application. This might cause subsequent errors or even crashes, but it will help to make the front end more robust.
abstract features
- added runtime error that checks that with one or several abstract inner feature are called unless there are no calls to the abstract feature. No fancy data-flow analysis is done yet, so the following code
  
  f { x { abstract y } z : x { redefine y { } } x; r ref x = z; r.y; }
  
  does not compile even though the only call to y is in an instance of z.
- added compile-time errors for the case that a feature with an implementation is marked as abstract

2020-09-30: V0.002

renamed intrinsic features for reference comparison as >>infix ===<< and

infix !==<< to avoid type errors when redefined in i32 and bool.
Added checks that redefined features match the argument and result types of the original features. No variance for argument types allowed (so far), covariance allowed for ref result type.
removed types int and String and last uses of int in testsuite, i32/string are used instead.

2020-09-29: V0.001

First version to be presented to very few selected users via the flang.dev website.

Esc sequence	result	unicode
'\b'	BS	0x08
'\t'	HT	0x09
'\n'	LF	0x0a
'\f'	FF	0x0c
'\r'	CR	0x0d
'"'	"	0x22
'$'	$	0x24
'''	'	0x27
'\'	\	0x5c
'{'	{	0x7b
'}'	}	0x7d

Files

release_notes.md

Latest commit

History

release_notes.md

File metadata and controls

2023--: V0.082

2023-04-05: V0.081

2023-01-12: V0.080

2022-12-08: V0.079

2022-08-15: V0.078

2022-08-03: V0.077

2022-07-27: V0.076

2022-07-04: V0.075

2022-05-31: V0.074

2022-05-18: V0.073

2022-04-23: V0.072

2022-04-01: V0.071

2022-02-25: V0.070

2022-02-25: V0.069

2022-02-04: V0.068

2022-01-30: V0.067

2022-01-24: V0.066

2022-01-21: V0.065

2022-01-06: V0.064

2022-01-03: V0.063

2021-10-29: V0.062

2021-10-15: V0.061

2021-09-30: V0.060

2021-09-02: V0.059

2021-08-23: V0.058

2021-08-20: V0.057

2021-07-30: V0.056

2021-07-21: V0.055

2021-07-08: V0.054

2021-07-06: V0.053

2021-06-30: V0.052

2021-06-29: V0.051

2021-06-23: V0.050

2021-06-22: V0.049

2021-06-18: V0.048

2021-05-31: V0.047

2021-05-30: V0.046

2021-05-24: V0.045

2021-05-24: V0.044

2021-05-21: V0.043

2021-05-20: V0.042

2021-05-19: V0.041

2021-05-18: V0.040

2021-04-20: V0.039

2021-04-20: V0.038

2021-04-14: V0.037

2021-04-08: V0.036

2021-04-07: V0.035

2021-04-06: V0.034

2021-03-29: V0.033

2021-03-25: V0.032

2021-03-19: V0.031

2021-03-18: V0.030

2021-03-17: V0.029

2021-03-16: V0.028

2021-03-15: V0.027

2021-03-11: V0.026

2021-03-10: V0.025

2021-03-09: V0.024

2021-03-05: V0.023

2021-03-02: V0.022

2021-02-24: V0.021

2021-02-22: V0.020

2021-02-18: V0.019

2021-02-12: V0.018

2021-02-07: V0.017

2021-02-01: V0.016

2021-01-12: V0.015

2020-11-22: V0.014

2020-11-16: V0.013

2020-11-13: V0.012

2020-11-10: V0.011

2020-11-06: V0.010

2020-11-03: V0.009