0.5.0

The most notable features of this new release are:

• Major syntax changes
• Immutability by default
• Tuples
• Checked subscript
• Performance improvements

Windows support is almost there and will probably be shipped in a minor release in the coming weeks.

Here is the full changelog

Major syntax changes

• Types are now specified after the identifier + : (#310). This includes:
  • Variable declarations
  • Function argument definitions
  • Catch clauses
  • if (...: type as ...)
• Arrow function use => instead of ->
• Comments and docblocks must now be prefixed by // and /// instead of | and ||
• Bitwise or operator is | instead of \
• Function type now use fun keyword instead of Function
• If a function type has multiple error types, they must be put in parenthesis
• Namespace can now be multiple \ separated identifiers
• Qualified name now use \ separator instead of .
• The float type is renamed to double (#311)
• Enum type is declared between <> rather than ()
• Protocol list object is conforming to is declared between <> rather than ()
• const keyword is renamed to final (#318)

Added

• Immutability by default (#139)
  • All non-scalar values are immutable by default
  • Mutability can be specified in types and for values with the mut keyword
  • Object methods that mutate this must be prefixed by mut
  • FFI data are considered mutable
• Compiler will warn about variable declared with var but never assigned
• Object can have final properties (#13)
• rg.subsetOf, rg.intersect, rg.union
• Tuples (#298): syntaxic sugar over anonymous objects:

const tuple = .{ "john", "james" };

tuple.@"0" == "john";

• Checked subscript access to list and strings (gives null when index is out of bound) (#304):

var list = [1, 2, 3];

list[?10] == null;

"hello"[?20] == null;

• User input is syntax highlighted in REPL (#217)
• REPL handles multilines input (#218)
• std\args(): returns the command line arguments with which the script was launched
• Compiler is better at inferring empty list/map type from their context (#86)

Modified

• Enum can now have rg, ud, void, pat as value type
• Anonymous object can also omit property name when initial value is a named variable
• Mir was updated to 1.0 (#300)

Fixed

• Type checking was not done on object instance property assignments
• Http client could not be collected because it kept connection opened to previous requests' domains
• Fixed an issue where a JIT compiled function making a lot of function calls would stack overflow

Internal

• Properties are now retrieved with an index rather than a hashmap lookup (#90) which gives a nice performance boost of about 40% on some benches

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,
};

• Sandboxing build options memory_limit and cycle_limit (#182)
• Block expression (#105):

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 with namespace 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 with import "..." _
• Ranges are now an actual buzz value (#170)
  • new rg type
  • myrange.toList() transforms a range into a list of integers
  • myrange.low and myrange.high to get a range bounds
  • works with foreach
• list.fill
• std.panic will panic and print current stack trace
• Loop can have labels that you can break or continue 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 optional maxSize 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? becomes fun 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 of std.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>
• Delimiters for non-standard identifiers (#138)
• Collectors (#2): if an object has a fun 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 float
  • bz_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 or const 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 renamed serialize
• Json now returns a Boxed 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>, ...) to myFunction::<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 type
• as? operator to safely cast something
• http 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 or fun main([str] args) > int, plus any required errors
• Numbers are splitted in two types: int (32 bits integers) and float (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
• zig/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.