Changelog for zeolite-lang-0.24.0.1
Revision history for zeolite-lang
0.24.0.1 -- 2023-12-10
Language
- [fix] Fixes parsing of
&.
with prefix/infix function notation, e.g.,a `foo&.bar` b
.
Compiler CLI
- [fix] Fixes static linking of binaries for C++ compilers that don't handle weak symbols. Previously, static linking would fail for some compilers with an error message related to functions that handle unboxed types.
0.24.0.0 -- 2023-12-09
Language
-
[breaking] In
testcase
, renamescrash
tofailure
. -
[breaking] Adds the
visibility
keyword to limit calling of@value
/@type
functions to specific type contexts. This is breaking becausevisibility
is now reserved.concrete Foo { visibility Bar, Baz // Functions below here are only visible from Bar or Baz. @type call () -> () }
-
[breaking] Adds function delegation with
delegate
keyword.concrete Foo { @type new1 (Int) -> (Foo) @type new2 (Int) -> (Foo) } define Foo { @value Int value new1 (value) { // Same as Foo{ value }. return delegate -> Foo } new2 (value) { // Same as new1(value). return delegate -> `new1` } }
This is a breaking change because
delegate
is now reserved. -
[breaking] In
testcase
, you can now optionally include a type name thatdefines Testcase
aftersuccess
/failure
. The test will automatically callstart()
andfinish()
, which is meant to allow custom checks upon test exit. This is breaking becauseTestcase
is now reserved. -
[breaking] Adds instance identification with the
identify
keyword. This is breaking becauseidentify
is now reserved. -
[fix] Fixes parsing of comments that immediately follow operators, e.g., the
/*b+*/
ina+/*b+*/c
. -
[fix] Fixes checking that a
@type
function isn't called on a@value
. -
[fix] Fixes cross-module visibility checks with
$TestsOnly$
in.0rp
without$ModuleOnly$
. This is primarily to detect if there's usage of a$TestsOnly$
category from aprivate_dep
in a.0rp
. -
[fix] Updates parsing of
empty
to allow explicit type conversion, e.g.,empty?String
. -
[new] Adds the option to provide enforced labels for function args.
concrete Foo { // First arg has the label value:. @type bar (Int value:) -> () } // ... // Callers _must_ use the label value:. \ Foo.bar(value: 1)
Unlike with languages like C++, where the argument name in the function declaration is irrelevant, this is primarily meant to clarify calls to functions with arguments whose purposes are ambiguous.
Note that this doesn't make arguments optional, nor does it allow reordering of arguments. Additionally, there's no requirement that the labels match the argument names, nor that the labels are even unique.
-
[new] Adds the
<-|
operator to conditionally overwrite anoptional
variable if it's empty.optional Int value <- empty value <-| 123 // Assigned, because value was empty. value <-| 456 // Not assigned, because value wasn't empty.
-
[new] Adds the
&.
operator to conditionally call a function on anoptional
value.optional Int value <- 123 optional Formatted formatted <- value&.formatted()
-
[new] Updates the return type of inline
<-
to use the type on the right side of the expression, rather than the variable's type.optional Formatted value <- empty // Previously, the return type would've been optional Formatted. Int value2 <- (value <- 123)
-
[new] Updates type inference to arbitrarily choose the lower bound when a param is bounded above and below with different types. Previously, the compiler would require specifying the param explicitly. This will make param inference succeed in more situations than it did previously.
-
[new] Adds the
<->
operator to swap variable values. This can be used to swap the values of writable variables of the same type, i.e., not marked as read-only via a pragma and not a function argument.Int foo <- 123 Int bar <- 456 foo <-> bar
-
[new] Allows hex, octal, and binary floating-point literals. (Exponents not allowed due to ambiguity during hex parsing.)
Float value1 <- \xFED.CBA Float value2 <- \o765.432 Float value3 <- \b101.010
-
[new] Adds the
$CallTrace$
macro to get a call trace for testing purposes.
Libraries
-
[breaking] Removes
Testing
fromlib/testing
entirely. Use the new testing approach instead. (More details in items further down.)// Old way. testcase "my tests" { success } unittest test { \ Testing.checkEquals("something", "other") \ Testing.checkBetween(3, 2, 7) }
// New way. testcase "my tests" { success TestChecker // <- allows lib/testing to manage test results } unittest test { \ "something" `Matches:with` CheckValue:equals("other") \ 3 `Matches:with` CheckValue:betweenEquals(2, 7) }
Also see the
.0rp
files inlib/testing
. -
[breaking] Removes
UtilTesting
fromlib/util
entirely. Use the new testing approach instead. -
[new] Adds the
TestChecker
testcase
checker (see previous section) tolib/testing
to help support custom matchers. -
[new] Adds support for custom value matchers in tests to
lib/testing
, as well as matchers for value comparisons, substring checks, floating-point epsilon, and container comparisons inlib/testing
,lib/util
, andlib/container
. User-defined matchers can compose other matchers to customize matching of more complex value types. -
[new] Implements
SetReader<#k>
forHashedMap<#k, #v>
andSortedMap<#k, #v>
inlib/container
. -
[new] Adds
tryValue
toErrorOr
inlib/util
. -
[fix] Updates
BarrierWait
C++ implementation to compile for MacOS by adding runtime failures if the functionality is used. MacOS doesn't support thread barriers, solib/thread
previously didn't compile for MacOS.
Compiler CLI
-
[new] Allows single-
-
CLI options to be clustered, e.g.,-rfj8
, which is expanded to-r
,-f
, and-j
8
. -
[behavior] Clearer error messages for categories hidden by
$ModuleOnly$
,$TestsOnly$
, andprivate_deps
. Previously, the compiler would just say that the category wasn't found.
0.23.0.0 -- 2022-10-08
Language
-
[breaking] Adds the
exit
builtin to terminate the program with an exit code, with the usual semantics, i.e., 0 means success. This is breaking becauseexit
is now a reserved name. -
[breaking] Adds the
Pointer<#x>
builtinconcrete
category, for use in C++ extensions. (This is breaking becausePointer
is now reserved.)
Compiler CLI
-
[new] Adds general pointer storage to
BoxedValue
to allow C++ extensions to pass data to each other without marshaling.// Create a value that can be returned/passed in Zeolite function calls. BoxedValue boxed = Box_Pointer<Foo>(&value); // Access the pointer stored in the value. Foo* unboxed = boxed.AsPointer<Foo>();
This is only type-safe if the Zeolite code uses a different
#x
inPointer<#x>
for each different type used withBox_Pointer
/AsPointer
. For example, the code above usesFoo
, soPointer<Foo>
should be used everywhere such values are passed around in the Zeolite code. (#x
is arbitrary, but it's more clear if the name used in Zeolite corresponds to the name of the C++ type.) -
[new] Adds % code coverage in output of
zeolite --missed-lines
.
Libraries
-
[new] Moves
Realtime
fromlib/thread
tolib/util
since it doesn't inherently require threads. (This isn't breaking becauselib/util
was already a public dependency oflib/thread
.) -
[new] Adds the
Counter.builder()
function tolib/util
to buildInt
counters with more flexibile limits and increments.
0.22.1.0 -- 2022-04-18
Language
-
[fix] Fixes checking of parameter variances in the context of internal inheritance.
-
[fix] Fixes regression in inheritance of interfaces where the specified params contain unions or intersections, e.g.,
refines Foo<[Bar&Baz]>
. -
[new] Adds the
$ReadOnlyExcept[...]$
define
pragma to protect all members except those specified.
Libraries
-
[new] Adds the
AlwaysEmpty
empty container tolib/util
. -
[new] Adds the
Queue<#x>
@value interface
and theSimpleQueue<#x>
container tolib/container
.
Compiler CLI
-
[fix] Fixes bug where
extra_files
listed in.zeolite-module
would fail to compile if the module contained no public categories. -
[new] Adds the
-j
[# parallel]
flag tozeolite
to execute compilation of C++ files in parallel. -
[new] Allows C++ extensions to specify internal inheritance in
.zeolite-module
. This is necessary if the implementation needs to passPARAM_SELF
orVAR_SELF
as a parent type that is not publicly visible.// Assumes that Foo is also mentioned in extra_files:. extension_specs: [ category { // For Foo<#x>. Do not include the params here. name: Foo refines: [Bar<#x>] defines: [Baz<#x>] } ]
0.22.0.0 -- 2021-12-11
Libraries
-
[breaking] Revises basic input and output provided by
lib/util
:-
[breaking] Renames
SimpleInput
toBasicInput
. -
[breaking] Renames
SimpleOutput
toBasicOutput
. -
[breaking] Removes
LazyStream
. To construct and write output, there are a few options:// Incrementally. \ BasicOutput.stderr() .write(someValue) .write("\n") .flush()
// Preformatted. \ BasicOutput.stderr().writeNow(String.builder() .append(someValue) .append("\n") .build())
-
-
[breaking] Renames
SearchTree
toSortedMap
inlib/container
. -
[breaking] Renames
TreeSet
toSortedSet
inlib/container
. -
[breaking]
Vector
changes (lib/container
):-
[breaking] Replaces
Vector:create<#x>()
withVector<#x>.new()
for consistency with other@value
construction. -
[breaking] Removes
Vector:copyFrom
since it was too specific.
-
-
[breaking] Removes
set
andremove
fromAutoBinaryTree
, and adds theswap
function, which can handle bothset
andremove
operations. -
[breaking] Removes
void
fromVoid
inlib/util
. UseVoid.default()
instead. -
[new] New categories:
-
[new] Adds the
HashedMap
andHashedSet
containers tolib/container
. -
[new] Adds
CategoricalReader
,RandomCategorical
, andGenerateConstant
tolib/math
. -
[new] Adds
FormattedH:try
tolib/util
for formatting values during debugging and logging. -
[new] Adds the
LessThan2
@value interface
tolib/util
. -
[new] Adds the
KVExchange
,KeyOrder
, andValueOrder
@value interface
s inlib/container
for additional map operations.
-
-
[new] New functionality for existing categories:
-
[new] Implements the new
KVExchange
,KeyOrder
, andValueOrder
interface
s forSortedMap
(previouslySearchTree
) inlib/container
. -
[new] Adds
copyTo
andduplicateTo
toOrderH
andReadAtH
inlib/util
for general container duplication. -
[new] Adds
forwardOrder
,reverseOrder
, anditerateWith
toReadAtH
inlib/util
for iterating overReadAt
containers. -
[new] Implements
Default
for containers inlib/container
andlib/math
. -
[new] Implements
Default
,Duplicate
, andHashed
forVoid
inlib/util
. -
[new] Implements
Sorting
functions inlib/container
that use the newLessThan2
interface
. -
[new] Implements
Append<Formatted>
forBasicOutput
(previouslySimpleOutput
) inlib/util
. -
[new] Adds
permuteFromWeight
toRandomize
inlib/math
. -
[new] Adds
probability
toRandomUniform
inlib/math
. -
[new] Adds
checkNotEquals
toTesting
inlib/testing
.
-
Language
-
[breaking] Makes the
Duplicate
@value interface
fromlib/util
a builtin and implements it forBool
,Char
,Float
,Int
, andString
. -
[breaking] Adds the
Hashed
builtin@value interface
and implements it forBool
,Char
,Float
,Int
, andString
. -
[breaking] Replaces
@value
conversion for function calls (e.g.,foo.Base.call()
to choosecall
fromBase
) with general type conversions usingvalue?Type
syntax.// Explicitly converts foo to Base. \ foo?Base.call()
The primary use-case is still to convert a union or interesection value to a specific type to resolve an ambiguity in function selection. Conversions can also be used to influence type inference in function calls by changing the type of a passed argument.
// Convert the argument when using type inference. \ call<?>(foo?[Container&ReadAt<#x>]) \ call<?>(foo?any)
This can also be used to convert the underlying types of
optional
andweak
values, while still preserving theoptional
/weak
storage modifier. -
[fix] Fixes checking of
defer
inin
blocks ofscoped
. Previously, adefer
red variable was only marked as set if thecleanup
set it, even if all paths through thein
actually set it.Int value <- defer scoped { // ... } in if (true) { value <- 1 } else { value <- 2 } // Previously, value appeared to be unintialized here. \ foo(value)
-
[fix] Fixes a bug in type checking of conversions to a parent
@value interface
when therefines
contains#self
.concrete Foo { // Previously, there would have been an error converting Foo -> Bar<Foo>. refines Bar<#self> }
-
[fix] Fixes bug in validation of internal
@category
functions with a param that has the same name as a category param, where the@category
function has a filter that the category does not have. -
[new] Allows
present
,require
,strong
, andreduce<#x,#y>
builtin functions to have unary notation, e.g.,y <- `require` x
. -
[new] Compiler now does more work attempting to resolve function calls for
@value
s with union types. Previously, explicit type conversions were always required to make calls from unions. -
[new] Allows
requires
andallows
filters to use unions and intersections on the right side, e.g.,#x allows [Foo&Bar]
. -
[new] Allows
defer
to be used with@value
and@category
members. This is primarily because the restriction was somewhat arbitrary. -
[new] Implements
LessThan
forBool
.
Compiler CLI
- [fix] Makes
PARAM_SELF
work when used in@value
implementations in C++ extensions.
0.21.0.0 -- 2021-11-19
Compiler CLI
-
[breaking] Combines params and args in function calls into a single object. This breaks all C++ extensions.
Call_foo
for functionfoo
must now takeconst ParamsArgs& params_args
as its only argument.- Access param
n
usingparams_args.GetParam(n)
. - Access arg
n
usingparams_args.GetArg(n)
.
- Access param
- Function calls must group params and args with
PassParamsArgs(params..., args...)
rather than withParamTuple(params...)
andArgTuple(args...)
. - To directly pass the returns from another function call, use that function
call in place of
args...
, e.g.PassParamsArgs(params..., TypeValue::Call(Var_foo, Function_Foo_bar, ...))
. - Value initialization should be changed to take
ParamsArgs
instead ofValueTuple
, since the latter has been removed. (Alternatively, just pass a custom set of arguments.) ReturnTuple
usage for returns remains unchanged.
-
[new] Updates dependency check to skip checking the modification times of
$ModuleOnly$
.0rp
source files when determining if the target module needs to be recompiled. -
[new] Adds
--clean
mode tozeolite
to clear cached data for a module. -
[new] Allows specifying a root path with
-p
in specialzeolite
execution modes, e.g.,--missed-lines
.
Libraries
-
[breaking] Makes
LinkedNode
inlib/container
weak in the reverse direction to avoid reference cycles. -
[new] Adds
Token
tolib/math
, for more efficient comparison of strings when used in algorithms. -
[new] Gives
Testing.checkEmpty
inlib/testing
a parameter to allow values that do not refineFormatted
. (This is not breaking because of the new language feature that infers params by default.) -
[new] Adds
getAll
toTypeMap
inlib/container
to read all values of a specified type. -
[new] Adds
checkTrue
andcheckFalse
toTesting
inlib/testing
.
Language
-
[new] Makes param inference the default when no params are specified in a function call. For example,
call<?>(foo)
can now becall(foo)
. -
[new] Adds syntax to select a single return value from a function that returns multiple values.
// Previous method: scoped { Foo foo, _ <- call() } in \ foo.bar() // New method: \ call(){0}.bar()
-
[new] Adds the
$FlatCleanup[
memberName
]$
pragma to enable non-recursive cleanup for deeply-recursive types like linked lists. -
[behavior] Removes all dynamic allocation when passing params and arguments in function calls.
-
[behavior] Improves efficiency of returning values from function calls.
-
[behavior] Improves efficiency of
Bool
,Char
,Float
, andInt
values when used in function calls and containers.
0.20.0.1 -- 2021-11-14
Language
- [fix] Fixes a regression where arguments ignored with
_
were not skipped over when generating C++. For example,call (_,x) { ... }
would result inx
being assigned the value that should have been ignored.
0.20.0.0 -- 2021-11-13
Language
-
[breaking] Adds the
immutable
category property. This makes all@value
members read-only, and requires their types to also beimmutable
. (This is breaking becauseimmutable
is now reserved.) -
[breaking] Allows temporarily postponing variable initialization using the
defer
keyword. (This is breaking becausedefer
is now reserved.) -
[breaking] Adds compilation error if multiple functions match the name of a function used in a call. This can happen when multiple
requires
ordefines
types have a function with the same name. -
[fix] Fixes merging of multiple functions with the same name inherited internally multiple times.
@value interface Base0 { call (Int) -> () } @value interface Base1 { call (String) -> () } concrete Type {} define Type { refines Base0 refines Base1 // This was previously missed when checking for an explicit merge of call. @value call (Formatted) -> () call (_) {} }
-
[fix] Removes the
types
reserved word, which was previously used for internal types. -
[fix] Fixes
update
calls intraverse
. Previously, theupdate
was not called forcontinue
. -
[new] Adds
$DisableCoverage$
unittest
pragma, to disable trace collection in--log-traces
when theunittest
is executed. -
[new] Updates
String.builder()
to acceptFormatted
values, rather than just acceptingString
. -
[new] Updates param inference to infer a param that is only used in filters for another param, if that other param occurs as a top-level argument.
// The caller can infer both #x and #y, even though there is no arg with #y. @type call<#x,#y> #x requires Foo<#y> (#x) -> ()
-
[behavior] Reduces memory size of
Bool
,Char
,Float
,Int
, and references to all other value objects. -
[behavior] Efficiency improvements for passing values in function calls.
-
[behavior] Skips calling
get
intraverse
if the value is discarded.// The _ suppresses the call to get() on the returned Order<Int> value. traverse (Counter.zeroIndexed(100) -> _) { // ... }
-
[behavior] Makes dispatching of function calls quite a bit more efficient.
Compiler CLI
-
[breaking] Updates caching of
TypeInstance
(i.e.,@type
) implementations in C++.- The argument type for
CreateType_Foo
for extensionFoo
must now be aconst
&
. For types with params, theInstanceCache
should be made global andstatic
. - A new function
void RemoveType_Foo
taking the sameparams
argument as the above must be added, which will be called when theTypeInstance
is destructed. For types with params, callRemove
on theInstanceCache
. Otherwise, it can be a no-op{}
.
(You can also just rerun in
--templates
mode and copy the updatedCreate
andRemove
functions.)Example for
concrete Foo<#x>
:static auto& Foo_instance_cache = *new InstanceCache<1, Type_Foo>([](const Params<1>::Type& params) { return S_get(new ExtType_Foo(CreateCategory_Foo(), params)); }); S<const Type_Foo> CreateType_Foo(const Params<1>::Type& params) { return Foo_instance_cache.GetOrCreate(params); } void RemoveType_Foo(const Params<1>::Type& params) { Foo_instance_cache.Remove(params); }
- The argument type for
-
[breaking] Removes all passing of
Param_self
in C++ extensions. UsePARAM_SELF
whereParam_self
was previously used, and delete theParam_self
argument from function signatures. This breaks all existing extensions that have@type
functions. -
[breaking] Makes all references to
TypeInstance
const
in C++, since Zeolite prohibits@type
members inconcrete
categories.All extensions with
@type
functions need to be updated:- Make all
Call_foo
overridesconst
for@type
functions. - Update
@value
constructors to takeS<const Type_Foo>
instead ofS<Type_Foo>
. - Update local params (e.g.,
Param_foo
) to have typeS<const TypeInstance>
. - Update
CreateType_Foo
to returnS<const Type_Foo>
instead ofS<Type_Foo>
.
- Make all
-
[breaking] Removes
AnonymousOrder
C++ class, previously used for creating iterators for C++ extensions. -
[new] Adds
--show-traces
mode tozeolite
to output a list of possible trace contexts when--log-traces
is used in-t
mode. -
[new] Adds
--missed-lines
mode tozeolite
to output all code lines for a module that are not in a provided file that was created by--log-traces
in-t
mode. -
[new]
@value
function implementations forimmutable
categories are marked asconst
in C++ extensions. -
[new] Allows modules to have additional subdirectories, specified in
.zeolite-module
with theextra_paths:
list section. This allows modules to separate.0rx
and.0rt
files from public.0rp
files.
Libraries
-
[breaking] Removes iterators from
lib/util
(iterator.0rp
) because they were awkward, inefficient, and had no current intended use-cases. -
[breaking] Requires the key param in
SearchTree
andAutoBinaryTree
inlib/container
to beimmutable
. -
[breaking] Requires the value param in
TreeSet
inlib/container
to beimmutable
. -
[breaking] Requires the value param in
CategoricalTree
inlib/math
to beimmutable
. -
[new] Adds the
LinkedNode
andForwardNode
linked-list types tolib/container
, and adds thesortList
,sortListWith
, andreverseList
functions toSorting
.
0.19.0.0 -- 2021-10-25
Compiler CLI
-
[breaking] Changes how
BoxedValue
is created for newTypeValue
instances in C++ extensions. Rather thanBoxedValue(new Foo(...))
, you must now useBoxedValue::New<Foo>(...)
. This breaks all existing extensions that instantiate new values. -
[breaking] Removes all passing of
Var_self
in C++ extensions. UseVAR_SELF
whereVar_self
was previously used, and delete theVar_self
argument from function signatures. This breaks all existing extensions.
Language
-
[fix] Fixes obscure memory leak in
weak
values, triggered by a very specific sequence of events between three threads. This leak was unlikely to affect any programs that did not specifically attempt to trigger it. -
[new] Allows
update
blocks fortraverse
loops.
Libraries
- [new] Adds
SpinlockMutex
tolib/util
, for more efficient locking when lockouts are rare or extremely short.
0.18.1.0 -- 2021-10-19
Language
- [fix] Fixes issue with explicit return discards skipping generation of
function calls. Previously,
_ <- foo()
skipped generating the call tofoo
.
Libraries
-
[new] Adds
RandomExponential
,RandomGaussian
, andRandomUniform
tolib/math
for generating randomFloat
values. -
[new] Adds
Realtime.sleepSecondsPrecise
function to allow sleeps that are more precise than the kernel's latency. -
[new] Adds
checkGreaterThan
andcheckLessThan
toTesting
inlib/testing
.
0.18.0.0 -- 2021-08-01
Compiler CLI
-
[breaking] Creates a single shared library per Zeolite module, and uses dynamic linking as the default for binaries and
testcase
s.--fast
mode still uses static linking, and static linking can be enabled for a binary using thelink_mode:
field in.zeolite-module
:root: "../.." path: "your/module" private_deps: [ "lib/util" ] mode: binary { category: YourProgram function: run link_mode: static }
-
[breaking] Eliminates dynamic memory allocation for
Bool
,Char
,Float
, andInt
, includingoptional
andweak
variants. This improves the efficiency of code that makes a lot of function calls using those types.Note that when used as variable types, those types already avoided dynamic allocation. This therefore only applies to passing them in function calls, and using them with
optional
andweak
.This breaks all existing C++ extensions:
S<TypeValue>
must be replaced withBoxedValue
.- Calls to
S_get
(only forValueType
) must be replaced with calls to theBoxedValue
constructor. W<TypeValue>
must be replaced withWeakValue
.- Calls to
W_get
must be replaced with calls to theWeakValue
constructor. - Calls to
->AsBool()
,->AsChar()
,->AsFloat()
,->AsInt()
,->AsCharBuffer()
, and->AsString()
must now use.
instead of->
. Present
,Require
, andStrong
are now inBoxedValue::
instead of inTypeValue::
.
(Running
zeolite --templates
again will provide the correct type signatures and local argument aliasing.) -
[breaking] Updates
zeolite -c
(library mode) andzeolite -m
(binary mode) to generate a new.zeolite-module
and exit. Previously, both modes would create.zeolite-module
and then attempt to compile it. The purpose of this change is to make users more aware that.zeolite-module
can/should be edited, rather than attempting to generate a "correct" config entirely from CLI flags. -
[new] Updates recompile mode (
zeolite -r
) to reorder modules explicitly specified in the command based on dependencies. For example, in the commandzeolite -r foo bar
, iffoo
depends onbar
,bar
will be compiled first. Previously, modules would be compiled in the order they were specified.Note that this will not account for indirect dependencies unless recursive mode (
-R
) is used. This is because dealing with the intermediate dependency would be ambiguous when not recompiling recursively. -
[behavior] Even more optimization for function calls using 4 or fewer arguments, returns, or function params.
-
[behavior] Updates the
fail
built-in to useSIGTERM
instead ofSIGABRT
to terminate the process, to prevent core dumps whenfail
is used to signal an unhandled error.
Language
-
[breaking] Adds the
Bounded
@type interface
for getting theminBound()
andmaxBound()
of a type, and implements it forInt
andChar
. (This is breaking becauseBounded
is now reserved.) -
[breaking] Makes
Char
unsigned when converting toInt
usingasInt()
. Previously, the value was signed, i.e., between -128 and 127. This change makes theInt
values line up better with hex and octChar
escapes. The conversion fromInt
toChar
(withasChar()
) is not affected. -
[new] Updates param inference (e.g.,
call<?>(foo)
) to handle param filters containing multiple inferred params. Previously, if a function had a filter such as#x requires #y
and both#x
and#y
were inferred, inference would fail because params were inferred one at a time. -
[new] Adds the
timeout
field totestcase
, to specify the number of seconds to allow eachunittest
to run. The default is30
, which should be more than enough for most individual tests. The primary purpose of setting a default is to prevent a deadlock or infinite loop from blocking continuous integration (CI) runners. -
[new] Updates parsing to allow calling functions on value intializers, and
Bool
,Char
, andString
literals without needing()
. For example,Type{ foo }.bar()
,true.asInt()
,'0'.asInt()
,"abc".defaultOrder()
.Int
andFloat
literals still require()
; otherwise, the use of.
would be ambiguous.
Libraries
-
[new] Adds
ParseChars
helper tolib/util
, to parseFloat
andInt
fromString
s. -
[new] Adds
monoSeconds()
toRealtime
inlib/util
, to get a monotonic wall time in seconds.
0.17.0.0 -- 2021-04-06
Language
-
[breaking] Adds
CharBuffer
, as a random-access, mutableChar
buffer, and makesWriteAt
a built-in type. (This is breaking becauseCharBuffer
andWriteAt
are now reserved.) -
[fix] Fixes
reduce<String,Container>
, which previously failed. -
[fix] Fixes a race condition in function dispatching that was thought to be fixed previously.
-
[behavior] Improves the memory efficiency of function calls that use 4 or fewer arguments, returns, or function params by reusing memory previously allocated for function calls.
Libraries
-
[new] Additions to
lib/util
:-
[new] Adds
Ranges
, for simple min/max determinations. -
[new] Adds
revZeroIndexed
toCounter
, to create a reversed sequence of zero-indexed container indices. -
[new] Adds
Reversed
,BySize
, andAlwaysEqual
comparators, to modifyLessThan
andEquals
behaviors for objects. -
[new] Adds
OrderH
andReadAtH
, to extendLessThan
andEquals
comparisons to simple containers.
-
-
[new] Additions to
lib/container
:-
[new] Adds
Sorting
, to support sorting of random-access containers. -
[new] Adds
TreeSet
, to manage set membership of any sortable type. -
[new] Adds
AutoBinaryTree
, to provide binary search tree (BST) functionality to custom containers that need to augment each node with additional data. -
[new] Implements
Container.size()
inSearchTree
. -
[new] Adds
KeyValueH
, to extendLessThan
andEquals
comparisons toKeyValue
.
-
-
[new] Adds
CategoricalTree
tolib/math
, as a dynamic representation of a categorical distribution over objects of any sortable type.
0.16.1.0 -- 2021-04-02
Language
-
[fix] Fixes a regression where a race condition in function dispatching would cause an error saying that a category does not implement the function that was being called.
-
[behavior] Optimizes calls to
@type
functions when made from@value
functions of the same type. -
[behavior] Optimizes
@value
initialization (e.g.,Type{ }
) when done from@type
functions of the same type.
Libraries
-
[new] Moves
Mutex
,SimpleMutex
, andMutexLock
fromlib/thread
tolib/util
. This is because they provide basic concurrency protection to objects that should not need to depend on-lpthread
.Note that this change is not breaking because
lib/util
was already a public dependency oflib/thread
. In other words, if a module already usedlib/thread
then it gotlib/util
for free. This means that modules only needing mutex functionality fromlib/thread
can instead uselib/util
. -
[new] Adds
getForward
andgetReverse
toSearchTree
, to allow the caller to iterate after looking up an entry. -
[new] Adds
checkEmpty
,checkPresent
, andcheckOptional
toTesting
inlib/testing
.
0.16.0.0 -- 2021-04-01
Language
-
[breaking] Disallows param filters in
@value interface
and@type interface
. Param filters are only used to allow procedures to call@type
and@value
functions. Previously, they were enforced in all situations where param substitution occurred, but this is no longer the case. (See further down in this list.) -
[breaking] Removes support for internal type params for values. This was an obscure feature that was never documented and was only used in some integration tests that had not been touched in over 2 years. This breaks most hand-written C++ extensions, but they can be fixed by removing the
ParamTuple
argument passed to the base-class constructor inExtValue_Foo
for C++ extensionFoo
. -
[breaking] Adds the
traverse
built-in syntax, which automatically iterates over a container that exposes the (new)Order<|#x>
@value interface
. (This is breaking becausetraverse
,Order
, andDefaultOrder
are now reserved.)traverse (container.defaultOrder() -> Foo value) { // executed once per Foo in the container }
-
[breaking] Marks
@category
member variables as read-only when initializing other member variables. Essentially, this just means that you can no longer do something like this:@category Int foo <- 1 @category Int bar <- (foo <- 2)
-
[new] Removes the requirement that type instances (e.g.,
Type<Int>
) satisfy the requirements of the type's parameter filters when not being used in a function call.concrete Type<|#x> { #x requires Foo }
In the example above,
Type<Bar>
was universally disallowed ifBar
could not be converted toFoo
. The new behavior is to enforce that restriction only when calling@type
functions, initializing values (e.g.,Type<#x>{ }
), and using the type as a param in a function call.Since
#x
is covariant in this example, you could convert aType<Bar>
to aType<any>
, even thoughany
is not a child ofFoo
. -
[new] Removes variance checks for category-level param filters. Variance was originally not checked, but then the checks were added prior to version
0.1.0.0
for obscure mathematical reasons that no longer make sense.In particular, filters such as
#x defines Equals<#x>
were not previously allowed except when#x
was invariant, but now it is allowed for all variances.The revised perspective is that param filters form a meta-type for param substitutions as inputs, with the constructed type as the output. Once the output is received, the input constraints are no longer recoverable.
Note that category-level param variance is still checked when params are used on the right side of filters for function params. This is because not doing so could result in bad argument and return types when inheriting functions.
Params also still cannot have both upper and lower bounds at the same time.
-
[new] When inferring type parameters for function calls (e.g.,
call<?>(foo)
), allowsall
to be a valid lower bound andany
to be a valid upper bound. Previously, an inferred type ofall
in covariant positions andany
in contravariant positions would cause inference to fail. -
[new] Allows
$ReadOnly[...]$
and$Hidden[...]$
for member variables in definitions ofconcrete
categories. -
[new] Makes
Argv
available to all threads. Previously, it was only available to the main thread. (Even thoughArgv
is exposed vialib/util
, this change also affects C++ extensions that useArgv
fromlogging.hpp
.) -
[fix] Fixes regression with function names used in stack traces. Previously, if a function was inherited and the types were not overridden, the category name in the trace would be that of the parent, rather than that of the one defining the procedure.
Compiler CLI
-
[breaking] Removes the default compiler mode when calling
zeolite
. The previous default was-c
, which creates a new.zeolite-module
for incremental library compilation. The default was removed because accidentally typingzeolite -f foo
instead ofzeolite -t foo
would overwrite the.zeolite-module
forfoo
rather than running its tests. -
[breaking] Updates how
$TraceCreation$
is implemented in C++. This only breaks hand-written C++ extensions that use theCAPTURE_CREATION
macro, which now must pass a string-literal category name as a macro argument, e.g.,CAPTURE_CREATION("Foo")
. -
[new] Adds the
--log-traces
option for testing mode (zeolite -t
) to capture a record of every line of Zeolite code executed when running tests. -
[fix] Fixes dependency resolution for C++ extensions that define
$ModuleOnly$
categories. -
[behavior] Improves the efficiency of call dispatching and
reduce
calls for categories that inherit a lot ofinterface
s. This is unlikely to affect performance when a category has less than 10 direct or indirect parentinterface
s.
Libraries
-
[new] Adds
ThreadCondition
tolib/thread
, which allows threads to wait for an arbitrary condition signaled by another thread. (Similar topthread_cond_t
in POSIX.) -
[new] Adds
EnumeratedBarrier
tolib/thread
, which can be use to synchronize a fixed number of threads. (Similar topthread_barrier_t
in POSIX, but with strict validation to help prevent deadlocks.) -
[new] Adds
Realtime
tolib/thread
, to allow threads to sleep based on wall time. -
[new] Adds
Counter
andRepeat
tolib/util
, to help create sequences for use with the newtraverse
built-in syntax. -
[new] Implements forward and reverse iteration to
SearchTree
inlib/container
.
Examples
- Adds
example/primes
, as a demonstration of multithreading.
0.15.0.0 -- 2021-03-24
Language
-
[breaking] Splits
Builder<#x>
built-in intoAppend<#x|>
andBuild<|#x>
to more accurately reflect its semantics. -
[breaking] Splits
ReadPosition<#x>
built-in intoReadAt<|#x>
,SubSequence
, andContainer
to be more concise, and to split up reading from subsequencing. This also includes renamingreadSize()
to justsize()
. -
[new] Adds the
Default
@type interface
, to specify a default@value
for the type. -
[fix] Fixes merging of duplicate inherited categories. Previously, if a category
Foo
was indirectly inherited multiple times then the compiler would complain about having multiple functions with the same name. -
[fix] Adds support for
^
with theBool
built-in type.
Libraries
-
[breaking] Refactors iterators in
lib/util
:-
[breaking] Makes
ReadIterator
a@value interface
. -
[breaking] Adds
AutoReadIterator
,AutoWriteIterator
, andAutoIterator
helpers to create iterators fromReadAt
andWriteAt
. (AutoReadIterator
replaces the previousReadIterator
.) -
[new] Adds
WriteAt
,WriteCurrent
,WriteIterator
, andIterator
@value interface
s.
-
-
[new] Adds
lib/container
:-
[new]
Vector
, a random-access container. -
[new]
SearchTree
, a binary search tree. -
[new]
TypeMap
, a heterogeneous key-value map of different value types. -
[new] Various
@value interface
s with container usage patterns.
-
-
[new] Adds
lib/thread
(must be built manually):-
[new]
ProcessThread
, a basic thread runner. -
[new]
SimpleMutex
andMutexLock
, for basic mutex logic. -
[new] Various
@value interface
s with thread usage patterns.
-
Compiler CLI
-
[breaking] Removes implicit dependence of C++ extensions on built-in categories
Bool
,Float
,Char
,Int
,String
, andFormatted
. Extensions that use these categories without using them in the correspondingconcrete
declaration will need to add them to therequires:
field of thecategory_source
in.zeolite-module
.category_source { source: "Extension_MyType.cpp" categories: [MyType] requires: [String,Formatted] }
-
[breaking] Cleans up
TypeInstance
caching for C++ extensions with parameters. Seelib/container/src/Extension_Vector.cpp
for an example of the new semantics, or use--templates
to create a new template.
Examples
- Removes
example/tree
. All of the corresponding code has been moved intolib/container
.
0.14.0.0 -- 2021-03-19
Language
- [breaking] Adds the
#self
meta-type. This is an implicit type param that is dynamically replaced with the type of the object a function is called on. For example, if a@value interface
function has a return type of#self
then any implementation must return an object of its own type from that function. (This is a breaking change because it reserves the param name#self
.)
Libraries
- [breaking] Removes the type parameters from
IterateForward
andIterateReverse
inlib/util
. This was made possible by the addition of the#self
meta-type.
0.13.0.0 -- 2021-03-17
Language
-
[new] Adds pragmas for local variable rules:
-
[new]
$ReadOnly[foo]$
marksfoo
as read-only in the current context following the line with the pragma. -
[new]
$Hidden[foo]$
hidesfoo
in the current context following the line with the pragma.
-
-
[fix] Fixes a latent issue with the
reduce
built-in when converting an intersection type to a union type, when one or both sides contains another nested union or intersection. This was previously fixed for compile-time checks, butreduce
was missed.
Compiler CLI
-
[breaking] Streamlines C++ extensions to cut down on boilerplate code. This is a massive change that breaks all existing C++ extensions; however, hand-written procedure definitions can be copied-and-pasted into a new extension template. Use
zeolite --templates
to regenerate new templates for C++ extensions. -
[breaking] Adds
microlens
andmicrolens-th
as dependencies, to help clean up the compiler code. This should not change the compiler's behavior.
0.12.0.0 -- 2020-12-11
Language
-
[breaking] Several more fixes for named returns:
-
[new] Allows initialization of named returns in
if
/elif
/while
predicates. Although setting a named return in a predicate has always been allowed, it previously did not count as an initialization for the purposes of checking usage in subsequent statements. -
[breaking] Fixes a bug where named returns used in
if
/elif
/while
predicates inside ofcleanup
blocks were not getting checked for initialization. This turns a potential runtime error into a compile-time error, which could break buggy code that was never going to be executed. -
[fix] Fixes a bug where a named return with a primitive type was not getting set in an explicit
return
statement. This only affected code that used primitive named returns inside of acleanup
block where the correspondingin
block used an explicitreturn
statement.@type call () -> (Int) call () (x) { cleanup { \ foo(x) // x was not getting set for this call } in return 1 // 1 was still returned from the function as expected }
This did not affect non-primitive types such as
String
and user-definedconcrete
andinterface
categories.
-
-
[breaking] Updates associativity of infix operators:
-
[breaking] Makes infix
Bool
operators&&
and||
right-associative. For example,x && y && z
used to be parsed as(x && y) && z
, whereas now it is parsed asx && (y && z)
. This better reflects the intuition of side-effects happening in order, with respect to short-circuiting. (No other operators currently short-circuit.) -
[breaking] Makes comparison operators (e.g.,
<=
) non-associative. This means that expressions such asx < y == true
will no longer compile. This is because an equivalent-looking expressiontrue == x < y
might have a different interpretation. (Note that order operators such as<
are not defined forBool
, so something likex < y < z
would have already failed previously.)
All other infix operators (including infix function calls such as
x `Math.pow` y
) remain left-associative. -
Libraries
- [new] Adds
Math.abs
forInt
absolute value tolib/math
.
0.11.0.0 -- 2020-12-09
Compiler CLI
- [breaking] Switches from
parsec
tomegaparsec
for parsing, to allow for better structuring of compile-time error messages. This should not affect syntax acceptance, but it has additional transitive dependencies that might prevent installation ofzeolite
.
Language
-
[breaking] Several
cleanup
fixes:-
[fix] Fixes a bug in
cleanup
that caused thescoped
block to be prepended to it when it was inlined in thein
block. -
[fix] Fixes a bug where
cleanup
might use an uninitialized named return when inlined at abreak
orcontinue
statement in awhile
loop. Such situations will now cause a compilation error. Previously, this could have allowed an uninitialized value to be passed around, which would only be noticed with aFunction called on null value
failure at some point. -
[fix] Fixes inlining of
cleanup
blocks whencontinue
is used inside of thein
block. Previously,cleanup
was skipped whencontinue
was used inside of the respectivein
block. -
[breaking] Disallows explicit
break
andcontinue
inside ofcleanup
blocks. Previously this was allowed (butreturn
wasn't), which led to ambiguity when thein
block contained areturn
. -
[new] Allows
cleanup
to refer to variables created at the top level of thein
block.cleanup { \ foo(bar) // bar is created below } in Type bar <- Type.create() // cleanup is inlined after this
-
0.10.0.0 -- 2020-12-05
Language
-
[breaking] Major changes to
.0rt
syntax:-
[breaking] Removes the expression argument from
success
andcrash
testcase
types. Use one or moreunittest
(see next point) instead. -
[new] Adds
unittest
keyword to allow the user to define multiple tests within a singlesuccess
testcase
.testcase "simple tests" { success } unittest checkInvariant1 { // this is a regular procedure with no return } unittest checkInvariant2 { // this is a regular procedure with no return }
This allows multiple tests to use the same setup, while still being able to track multiple test failures.
error
andcrash
testcase
types are still available. -
[breaking] Allows
testcase
to statically setArgv
(seelib/util
) using theargs
keyword. By default, only the program name is set. Previously,Argv
used whatever was passed to the test binary.testcase "with static Argv" { success args "arg1" "arg2" } unittest test { // something that requires Argv.global() }
Note that this isn't a library change; this also affects C++ extensions that use
Argv
frombase/logging.hpp
. -
[new] Adds
compiles
mode fortestcase
. This is likesuccess
except nothing is executed. (success
requires at least oneunittest
, whereascompiles
will not execute anything even ifunittest
are present.)
-
Libraries
- [new] Adds the
lib/testing
library with basic helpers for unit tests.
Compiler CLI
-
[new] Updates parsing of
.zeolite-module
to allow any ordering of the fields. Previously, the fields needed to be in a very specific order. -
[fix] Adds compile-time protection against self-referential expression macros defined in
expression_map:
in.zeolite-module
. Previously, the result was infinite recursion that could exhaust system resources. -
[breaking] Adds an error when
root
/path
in.zeolite-module
differs from the location of the respective.zeolite-module
. This is to catch both typos (e.g., copy-and-paste errors) and ambiguities.
0.9.0.0 -- 2020-11-23
Compiler CLI
-
[breaking] Major changes to C++ extensions:
-
[breaking] Corrects hole in
$ModuleOnly$
visibility in C++ extensions. Previously, C++ extensions could directly access categories defined in$ModuleOnly$
sources in dependencies. -
[breaking] Randomizes cache paths and
namespace
s for generated C++ code so that C++ extensions cannot use static#include
paths to circumvent the visibility rules of a dependency. -
[breaking] Makes
TypeInstance
s shared in generated C++ and in C++ extensions, to allow for better memory management of@type
s in the future. -
[breaking] Adds guards to C++ headers for
$TestsOnly$
categories, to prevent them from being used in non-$TestsOnly$
C++ extensions.
-
-
[fix] Fixes regression where calling
zeolite
with-p
would overwrite an existing.zeolite-module
.
Language
-
[breaking] Syntax changes:
-
[breaking] Changes the syntax for calling
@category
functions from$$
to:
, e.g.,Foo:create()
instead ofFoo$$create()
. A new error message (to be removed later) will remind the user to stop using$$
. -
[breaking] Changes the syntax for calling
@type
functions from$
to.
, e.g.,Foo.create()
instead ofFoo$create()
. A new error message (to be removed later) will remind the user to stop using$
.
-
-
[breaking] Changes to param usage:
-
[breaking] Updates param inference to be more accurate. The new algorithm will infer a param type iff the best choice is unambiguous given the expected and actual function arguments.
-
[breaking] Disallows bounding a single param both above and below, e.g., having both
#x requires Foo
and#x allows Bar
. This is primarily to prevent cycles and contradictions in the type system.Previously, the best case for such restrictions was that there are extremely few choices for
#x
, and the worst case was that it impliesBar
converts toFoo
when it isn't true, thus making#x
unusable. Having either of those requirements likely indicates a design flaw.
-
-
[breaking] Prohibits having a
$TestsOnly$
definition for a non-$TestsOnly$
category. Previously, aconcrete
category declared in a non-$TestsOnly$
.0rp
could bedefine
d in a$TestsOnly$
.0rx
, which creates a loophole that allows binaries to utilize$TestsOnly$
code. -
[fix] Fixes a latent type-checking bug that could occur when attempting to assign a value with an intersection type to a variable with a union type, if one or both types has another nested type, e.g.,
[A&B]
→[[A&B]|C]
or[[A|B]&C]
→[A|B]
. This change shouldn't cause new type-checking failures.
Libraries
- [fix] Implements
subSequence
forArgv
inlib/util
. This is required byReadPosition
but was forgotten. Calling it prior to this would cause a failure.
0.8.0.0 -- 2020-08-07
Language
-
[breaking] Makes the semantics of
cleanup
more consistent:-
[breaking] Disallows statements that modify
return
values withincleanup
blocks, i.e.,return
with values and assigning named returns. -
[new] Allows
cleanup
to access named returns that are initialized within the correspondingin
statement. Previously, access required initialization before thein
statement. -
[new] An explicit positional return (e.g.,
return 1, 2
) will assign the values to the respective named returns, if applicable. This will make the actual return values available withincleanup
.@type get () -> (Int) get () (foo) { // foo is the name of the return variable cleanup { \ bar(foo) // foo has been initialized by the time this is called } in return 1 // 1 is assigned to foo here }
-
[fix] Adds unwinding of
cleanup
blocks when used withbreak
andcontinue
, respecting loop boundaries. Previously,cleanup
was ignored.
-
-
[breaking] Skips compilation of unreachable statements. The target use-case is temporary changes to code that circumvent parts of a procedure, e.g., an early
return
for the purposes of debugging. -
[breaking] Marks statements following
break
andcontinue
as unreachable.
Compiler CLI
- [behavior] Adds a compiler warning for
public_deps
that are not required by public.0rp
sources within the same module, since they are potentially just cluttering the public namespace of the module.
0.7.1.0 -- 2020-07-13
Language
-
[new] Adds the
$SourceContext$
macro, which inserts aString
with info about source file and code location. -
[fix] Adds context to error messages related to inherited functions that have not been overridden.
0.7.0.2 -- 2020-05-21
Language
- [fix] Improves the likelihood of successful type inference when unions, intersections, or filters are combined with inheritance and type nesting.
0.7.0.1 -- 2020-05-20
Language
-
[fix] Fixes an edge-case where type-inference can be influenced by a param filter for a param with the same name in the scope that is calling the function. (For example, having
#x requires Foo
in scope while calling a function that also happens to have a param named#x
.) -
[fix] Fixes an edge-case where parameter substitution at the type level can clash with a type parameter scoped to a function. (Related to the above, but actually a separate issue discovered while solving the former.)
-
[behavior] Shows inferred-type assignments in error messages related to expressions containing inferred types.
0.7.0.0 -- 2020-05-19
Language
-
[new] Adds limited inference of type parameters in function calls. The new syntax is
call<?,Int>(foo,bar)
, where?
designates that inference is requested for the first position. -
[behavior] Reduces the memory cost of
$TraceCreation$
by avoiding storing the entire trace text.
Compiler CLI
- [behavior] Improves handling of I/O errors when calling
zeolite
, and allows compilation to continue in-r
/-R
modes if compilation of one module fails.
0.6.0.0 -- 2020-05-14
Compiler CLI
-
[behavior] Improves error messages for type mismatches and return-count mismatches.
-
[behavior] Improves the efficiency of loading metadata for dependencies.
-
[breaking] Fixes module-staleness check when running tests (
-t
). -
[breaking] Prevents binaries from being created from main categories that are defined in
$TestsOnly$
sources. (This was the original intention, but it was missed the first time around.)
Language
-
[new] Allows
@category
members inconcrete
categories to refer to each other during initialization. -
[new] Adds the
$ExprLookup[
MACRO_NAME
]$
pragma, which allows the user to define expression substitutions in.zeolite-module
. -
[new] Adds the
$NoTrace$
pragma, which skips generating stack-trace information for specific functions. This is useful for deeply-recursive functions whose full trace would not be useful. -
[new] Adds the
$TraceCreation$
pragma, which appends a trace for the creation of a value when there is a crash in one of its functions. This is useful when the crash stems from value initialization. -
[fix] Fixes parsing of the
'"'
Char
-literal.
Libraries
-
[new] Adds the
ErrorOr<#x>
category tolib/util
. This allows functions to return either the expected type or an error message. -
[new] Adds the
Void
category tolib/util
. This can be used to ignore type parameters when a value still needs to be instantiated. -
[new] Adds the
readAll
function toTextReader
(inlib/util
) to support reading an entire file at once. -
[breaking] Adds crashes when attempting to read
RawFileReader
or writeRawFileWriter
if there is a preexisting file error.
0.5.0.0 -- 2020-05-12
-
[new] Adds compiler support for pragmas, which will allow compiler features that aren't a part of the language:
-
[new]
$ModuleOnly$
pragma for.0rp
files, which limits their visibility to the modules that own them. -
[new]
$TestsOnly$
pragma for.0rp
files, which limits their visibility to.0rt
files, and.0rx
files that also use$TestsOnly$
.
-
-
[new] Adds support for global seach paths for dependencies via a plain-text file at
$(zeolite --get-path)/global-paths
. This can be used to set up a separate directory for general-use Zeolite modules. -
[breaking] Better handling of symbols from dependencies. This might break code that inavertently relied on broken visibility. In particular,
..
in a dependency path precludes it from resolving to a system module.
0.4.1.0 -- 2020-05-05
-
[new] Adds a compiler mode (
--show-deps
) to display the symbolic dependencies of a module. -
[new] Adds a compiler mode (
--fast
) to quickly compile a binary from a single source file without needing to create a module. -
[new] Adds a compiler mode (
-R
) to recursively recompile modules. -
[new] Improves thread-safety of internal code so that thread support can be safely added later. (Probably via a library.)
-
[new] Adds the
Builder
interface to makeString
concatenation more efficient. -
[new] Adds support for basic mathematical
Float
operations, such assin
,exp
, andsqrt
. -
[new] Adds support for bitwise
Int
operations. -
[fix] Fixes broken
--templates
mode when builtin types are used.
0.4.0.0 -- 2020-05-05
-
[new] Allows modules to specify custom linker flags and private include paths in
.zeolite-module
. This lets categories written in C++ depend on external libraries written in other languages. -
[behavior] Adds optimization of dependency inclusion for categories that are defined in C++ sources. This should eliminate linking in object files that are not needed by the binary.
-
[behavior] Adds checks to prevent a module from defining a category that was declared in another module.
-
[breaking] Updates the
.zeolite-module
format to require associating externally-defined categories with the source files that define them. This allows finer-grained linking of binaries and tests.
0.3.0.0 -- 2020-05-03
-
[breaking] Updates syntax for discarding all returns to use
\
instead of~
. This will allow~
to be used for bitwise-not later on. (Not to mention that~
was kind of ugly in that context.) -
[breaking] Cleans up multiple-
return
syntax by removing{}
. This applies to both thereturn
and the assignment.
0.2.0.0 -- 2020-05-03
-
[breaking] Requires that
concrete
categories defined in.cpp
files be listed asexternal
in.zeolite-module
. This allows the compiler to ensure that all categories have a definition, which helps avoid linker errors. -
[breaking] Gives
.zeolite-module
configs a proper file format. -
[new] Adds version checking to cached module data.
0.1.3.0 -- 2020-05-01
- [new] Adds support for more versions of GHC.
0.1.2.0 -- 2020-04-28
-
[fix] Fixes a parser issue with empty
{}
blocks followingscoped
. -
[behavior] Updates
cleanup
procedures to allow setting named-return values. Previously, initializing a named return incleanup
was not sufficient. -
[behavior] Updates
zeolite-setup
to unconditionally rebuild supporting libraries. Incidentally, this causes all existing user modules to be out of date.
0.1.1.0 -- 2020-04-27
-
[behavior] Set the default output path for binaries to the module's path rather than the current directory.
-
[new] Allows a base path (
-p
) with recompile mode (-r
).
0.1.0.0 -- 2020-04-27
- First version. Released on an unsuspecting world.