Releases: buzz-language/buzz
0.4.0
The most notable features of this new release are:
- REPL
- WASM build and web REPL
- Tracing JIT
Here is the full changelog:
Added
- REPL (#17) available by running buzz without any argument
- WASM build (#142) and web REPL
- Tracing JIT (#134): will look for hot loops and compile them
- Tail call optimization (#9)
- Function argument names and object property names can be omitted if the provided value is a named variable with the same name (#204)
object Person {
str name,
str lastName,
}
const name = "Joe";
const lastName = "Doe";
before:
const person = Person {
name: name,
lastName: lastName,
};
after:
const person = Person {
name,
lastName,
};
var value = from {
| ...
out result;
}
recursive_call_limit
build option limit recursive calls- Compiler will warn about code after a
return
statement - Compiler will warn about unreferenced imports (#272)
namespace
(#271): if a script exports at least one symbol, it has to define a namespace for the script withnamespace mynamespace
- By default, imported symbols from another script will be under
libprefix.XXXX
- When importing something, you can still redefine its namespace prefix with
import "..." as mynewnamespace
or remove it altogether withimport "..." _
- By default, imported symbols from another script will be under
- Ranges are now an actual buzz value (#170)
- new
rg
type myrange.toList()
transforms a range into a list of integersmyrange.low
andmyrange.high
to get a range bounds- works with
foreach
- new
list.fill
std.panic
will panic and print current stack trace- Loop can have labels that you can
break
orcontinue
to (#199)
Changed
- Map type notation has changed from
{K, V}
to{K: V}
. Similarly map expression with specified typed went from{<K, V>, ...}
to{<K: V>, ...}
(#253) File.readLine
,File.readAll
,Socket.readLine
,Socket.readAll
have now an optionalmaxSize
argument- Empty list and map without a specified type resolve to
[any]
/{any: any}
unless the variable declaration context provides the type (#86) - Function yield type is now prefixed with
*>
:fun willYield() > T > Y?
becomesfun willYield() > T *> Y?
(#257) - Temporarily disabled
--tree
and--fmt
. The AST has been completely reworked and those feature will take some work to come back. math.random
removed in favor ofstd.random
Fixed
- A bunch of crash after reported error. buzz tries to hit a maximum of syntax/compile errors by continuing after an error has been reported. This can lead to unexpected state and crash.
- Trying to resolve a global when only its prefix was provided would result in infinite recursion
- Forbid use of
yield
/resume
/resolve
in the global scope - Would break on unfinished char literal
Note: No binaries are provided until I figure out #226
0.3.0
The most notable features of this new release are:
- The introduction of FFI allowing buzz to call C functions very easily (see this example using SDL).
object
generic types- Type values
- The new
var
keyword
Here is the full changelog:
Added
- FFI (#109)
- Uses MIR to generate wrappers around imported functions and to generate getters and setters to struct fields
- New
zdef
statement to declare and bind foreign functions and struct using zig code - New
ffi
std lib - When you need a pointer to something you can use the
Buffer
std lib object. Added:Buffer.writeZ
,Buffer.readZ
,Buffer.writeStruct
,Buffer.readStruct
Buffer.ptr
,Buffer.len
- New (fancy) error reporter (#153)
- Errors have now an associated code
os.sleep
- First class types (#21)
- Type can be passed around as values like so:
<str>
- New
typeof
operator returns type of any value:typeof "hello"
-><str>
- Type can be passed around as values like so:
- Delimiters for non-standard identifiers (#138)
- Collectors (#2): if an
object
has afun collect() > void
method, it will be called before an instance of this object is collected by the garbage collector - Helpers around
ud
std.toUd
, returns userdata from an int or floatbz_valueToObjUserData
bz_getUserDataPtr
Buffer.readUserData
,Buffer.writeUserData
std.serialize
takes any buzz value and return a serializable version of it (objects become maps, etc.) provided the data is has no circular reference and does not contain not serializable values (functions, fibers, etc.)- UTF8 helpers:
str.utf8Len
,str.utf8Codepoints
,str.utf8Valid
(#39) - New integer literal for single chars:
'A' == 65
(#172) - Compiler will warn you when a local or global is never used or when an expression value is discarded. To silence those warnings you can use the
_ = <expression>
or name the local/global_
. std.currentFiber
,fiber.isMain
(#162)map.sort
,map.forEach
,map.map
,map.filter
,map.reduce
,map.diff
,map.intersect
,map.clone
(#110)list.clone
(#110)- Number literals can embed
_
:1_000_000.300_245
(#163) - Type can be inferred when declaring a variable/constant with the
var
orconst
keyword:var something = "hello"
(#194) - Objects can have generic types (#82)
- Draft of the testing std lib (#129)
File.isTTY
fs.exists
- Functions annotated with a comment of the form
|| @hot
will always be JIT compiled
Changed
json
lib is renamedserialize
Json
now returns aBoxed
object (which can be reused in other contexts than JSON)- Identifiers can now have
_
since pattern delimiters have changed - Changed pattern delimiters to
$"..."
(#165) list.append
does not return the appended value anymore- Generic types syntax changed from
myFunction(<K,V>, ...)
tomyFunction::<K,V>(...)
- Nullable object fields and nullable variables have a
null
initial value if none is provided - Migrated to pcre2 which is now a submodule built by build.zig
- Mimalloc is now a submodule built by build.zig
Fixed
- Some bugs
any
- Runtime error stack trace was wrong
- Local name checking failed in some instances
- Compiler would not force you to give variables an initial value
- Compiler would crash after raising some errors
- Float operation were sometimes wrong
- Catch clause were sometimes not reached in a JIT compiled function
- Stacktraces of errors reported from within a fiber were wrong
catch (any error)
was not considered as catching all possible errors by the compiler- Full GC sweep were never triggered
0.2.0
A lot of work went into implementing the JIT compiler: first with LLVM then with MIR which was way faster at compiling. There's also a lot of new features, fixes and changes. See below.
Added
- buzz has a homepage: https://buzz-lang.dev, a Discord and an actual VS Code extension
- JIT compiler powered by MIR
- mimalloc as the main allocator
- Inline if
- Ranges
any
typeas?
operator to safely cast somethinghttp
standard lib (with an HTTP client)crypto
standard lib (in progress)list.pop
,list.insert
,list.forEach
,list.reduce
,list.filter
,list.map
,list.reduce
,list.sort
pattern.replace
,pattern.replaceAll
std.random
bz_call
allows a native function to call a buzz function--ast
will dump a script AST in JSON--check
will check that a script compiles whitout running it- Shebang comment is allowed (
#!/usr/bin/env buzz
) at the start of a script
Changed
- Main function signature must either be
fun main([str] args) > void
orfun main([str] args) > int
, plus any required errors - Numbers are splitted in two types:
int
(32 bits integers) andfloat
(64 bits floating points) - Some performance related changes
- VM uses tail calls to dispatch opcode instead of a big switch
- More specialized opcodes to avoid checking types at runtime
- Some minor things...
- Key can be omitted in
foreach
statements - buzz wil now search a library in a list of common directories
export
can prefix declarations
Fixed
Too many to count...
0.1.0
This is the first version of buzz.
Here's a quick summary of buzz features as of this release:
- strong type system
- null safety
- "error safety": much like zig, function signatures must specify which errors can be raised and error must be handled
- objects (struct-like, no inheritance)
- anonymous objects
- protocols
- enums
- lists and maps
- fibers (coroutines)
- userdata (pointer to foreign data wrapped in a buzz value)
- first-class citizen functions
- arrow functions
- generics
- pcre regex
- zic/c interop
- syntax highlighting via vs code extension or by using the TextMate grammar file
- minimal std lib: buffer, fs, io, os, math, gc, debug
You are all welcome to play with buzz and report any issue you encounter.
Please read the README for build instructions and a tour of the language. Documentation for the standard library of the language can be found here.
You'll find binaries for macOS-x86 below. Although I recommend building buzz yourself right now.