Janet 1.9.1

This releases fixes several issues with 1.9.0 that prevented it from running in certain configurations. Should be otherwise compatible with 1.9.0.

• Add :prefix option to declare-source
• Re-enable minimal builds with the debugger.
• Add several flags for configuring Janet on different platforms.
• Fix broken meson build from 1.9.0 and add meson to CI.
• Fix compilation issue when nanboxing is disabled.

Janet 1.9.0

This release brings a lot of updates, mainly the beta net/ module that brings asynchronous, non-blocking socket networking to Janet's core. As per usual, check the changelog for updates and happy hacking!

• Add :ldflags option to many jpm declare functions.
• Add errorf to core.
• Add lenprefix combinator to PEGs.
• Add %M, %m, %N, and %n formatters to formatting functions. These are the
  same as %Q, %q, %P, and %p, but will not truncate long values.
• Add fiber/root.
• Add beta net/ module to core for socket based networking.
• Add the parse function to parse strings of source code more conveniently.
• Add jpm rule-tree subcommand.
• Add --offline flag to jpm to force use of the cache.
• Allow sending pointers and C functions across threads via thread/send.
• Fix bug in getline.
• Add sh-rule and sh-phony to jpm's dialect of Janet.
• Change C api's janet_formatb -> janet_formatbv, and add new function janet_formatb to C api.
• Add edefer macro to core.
• A struct/table literal/constructor with duplicate keys will use the last value given.
  Previously, this was inconsistent between tables and structs, literals and constructor functions.
• Add debugger to core. The debugger functions are only available
  in a debug repl, and are prefixed by a ..
• Add sort-by and sorted-by to core.
• Support UTF-8 escapes in strings via \uXXXX or \UXXXXXX.
• Add math/erf
• Add math/erfc
• Add math/log1p
• Add math/next
• Add os/umask
• Add os/perm-int
• Add os/perm-string
• Add :int-permissions option for os/stat.
• Add jpm repl subcommand, as well as post-deps macro in project.janet files.
• Various bug fixes.

Janet 1.8.1

Small patch on 1.8.0, fixing issues on big endian platforms and BSDs. Otherwise, more or less the same as 1.8.0.

Janet 1.8.0

Version 1.8.0! Mostly small fixes and a number of additions to the core library. Also exposes signals to Janet programs for custom control flow, which previously was only available from C.

• Add reduce2, accumulate, and accumulate2.
• Add lockfiles to jpm via jpm make-lockfile and jpm load-lockfile.
• Add os/realpath (Not supported on windows).
• Add os/chmod.
• Add chr macro.
• Allow _ in the match macro to match anything without creating a binding
  or doing unification. Also change behavior of matching nil.
• Add :range-to and :down-to verbs in the loop macro.
• Fix and and or macros returning nil instead of false in some cases.
• Allow matching successfully against nil values in the match macro.
• Improve janet_formatc and janet_panicf formatters to be more like string/format.
  This makes it easier to make nice error messages from C.
• Add signal
• Add fiber/can-resume?
• Allow fiber functions to accept arguments that are passed in via resume.
• Make flychecking slightly less strict but more useful
• Correct arity for next
• Correct arity for marshal
• Add flush and eflush
• Add prompt and return on top of signal for user friendly delimited continuations.
• Fix bug in buffer/blit when using the offset-src argument.
• Fix segfault with malformed pegs.

Janet 1.7.0

Many new functions and macros that should be generally useful, like assert and eachk. There is some backwards incompatibility in the Janet core with the removal of the numeric operators (==, not==, etc), removal of the emscripten build, removal of file/fileno and file/fdopen, and some changes to comparison functionality for abstract types. Many other small changes in the Changelog.

• Remove file/fileno and file/fdopen.
• Remove ==, not==, order<, order>, order<=, and order>=. Instead, use the normal
  comparison and equality functions.
• Let abstract types define a hash function and comparison/equality semantics. This lets
  abstract types much better represent value types. This adds more fields to abstract types, which
  will generate warnings when compiled against other versions.
• Remove Emscripten build. Instead, use the amalgamated source code with a custom toolchain.
• Update documentation.
• Add var-
• Add module/add-paths
• Add file/temp
• Add mod function to core.
• Small bug fixes
• Allow signaling from C functions (yielding) via janet_signalv. This
  makes it easy to write C functions that work with event loops, such as
  in libuv or embedded in a game.
• Add '%j' formatting option to the format family of functions.
• Add defer
• Add assert
• Add when-with
• Add if-with
• Add completion to the default repl based on currently defined bindings. Also generally improve
  the repl keybindings.
• Add eachk
• Add eachp
• Improve functionality of the next function. next now works on many different
  types, not just tables and structs. This allows for more generic data processing.
• Fix thread module issue where sometimes decoding a message failed.
• Fix segfault regression when macros are called with bad arity.

Janet 1.6.0

Large release to Janet, with a few breaking changes to the C API. This will not be a major release, however, as the change is small enough and the language young enough. This release also includes the addition of threads, which work on bot posix systems with pthreads, and Windows with the win32 api. See the changelog for more details.

• Add thread/ module to the core.
• Allow seeding RNGs with any sequence of bytes. This provides
  a wider key space for the RNG. Exposed in C as janet_rng_longseed.
• Fix issue in resume and similar functions that could cause breakpoints to be skipped.
• Add a number of new math functions.
• Improve debugger experience and capabilities. See examples/debugger.janet
  for what an interactive debugger could look like.
• Add debug/step (janet_step in the C API) for single stepping Janet bytecode.
• The built in repl now can enter the debugger on any signal (errors, yields,
  user signals, and debug signals). To enable this, type (setdyn :debug true)
  in the repl environment.
• When exiting the debugger, the fiber being debugged is resumed with the exit value
  of the debug session (the value returned by (quit return-value), or nil if user typed Ctrl-D).
• (quit) can take an optional argument that is the return value. If a module
  contains (quit some-value), the value of that module returned to (require "somemod")
  is the return value. This lets module writers completely customize a module without writing
  a loader.
• Add nested quasiquotation.
• Add os/cryptorand
• Add prinf and eprinf to be have like printf and eprintf. The latter two functions
  now including a trailing newline, like the other print functions.
• Add nan?
• Add janet_in to C API.
• Add truthy?
• Add os/environ
• Add buffer/fill and array/fill
• Add array/new-filled
• Use (doc) with no arguments to see available bindings and dynamic bindings.
• jpm will use CC and AR environment variables when compiling programs.
• Add comptime macro for compile time evaluation.
• Run main functions in scripts if they exist, just like jpm standalone binaries.
• Add protect macro.
• Add root-env to get the root environment table.
• Change marshalling protocol with regard to abstract types.
• Add show-paths to jpm.
• Add several default patterns, like :d and :s+, to PEGs.
• Update jpm path settings to make using jpm easier on non-global module trees.
• Numerous small bug fixes and usability improvements.

Janet 1.5.1

Patch on 1.5.0. Fixes a handful of bugs, but is otherwise backwards compatible.

Janet 1.5.0

This release brings a lot of updates to Janet, with some small, potentially backwards incompatible changes.

Changelog:

• os/date now defaults to UTC.
• Add --test flag to jpm to test libraries on installation.
• Add math/rng, math/rng-int, and math/rng-uniform.
• Add in function to index in a stricter manner. Conversely, get will
  now not throw errors on bad keys.
• Indexed types and byte sequences will now error when indexed out of range or
  with bad keys.
• Add rng functions to Janet. This also replaces the RNG behind math/random
  and math/seedrandom with a consistent, platform independent RNG.
• Add with-vars macro.
• Add the quickbin command to jpm.
• Create shell.c when making the amalgamated source. This can be compiled with
  janet.c to make the janet interpreter.
• Add cli-main function to the core, which invokes Janet's CLI interface.
  This basically moves what was init.janet into boot.janet.
• Improve flychecking, and fix flyching bugs introduced in 1.4.0.
• Add prin, eprint, eprintf and eprin functions. The
  functions prefix with e print to (dyn :err stderr)
• Print family of functions can now also print to buffers
  (before, they could only print to files.) Output can also
  be completely disabled with (setdyn :out false).
• printf is now a c function for optimizations in the case
  of printing to buffers.

Janet 1.4.0

This release brings fxes and updates to jpm and the core library. Stacktraces should now be easier to read as they use line and column information instead of byte offsets. Also added some simple compile time error checking to functions that are called with the the wrong arity.

Pckages can be installed via jpm install json, where json is a package name in https://github.com/janet-lang/pkgs, or any other package registry that is set via the JANET_PKGLIST environment variable. A package registry is just a package that follows the format in https://github.com/janet-lang/pkgs.git.

Changelog

• Add quit function to exit from a repl, but not always exit the entire application.
• Add update-pkgs to jpm.
• Integrate jpm with https://github.com/janet-lang/pkgs.git. jpm can now install packages based on their short names in the package listing, which can be customized via an env variable.
• Add varfn macro
• Add compile time arity checking when function in function call is known.
• Added slice to the core library.
• The */slice family of functions now can take nil as start or end to get the same behavior as the defaults (0 and -1) for those parameters.
• string/ functions that take a pattern to search for will throw an error when receiving the empty string.
• Replace (start:end) style stacktrace source position information with line, column. This should be more readable for humans. Also, range information can be recovered by re-parsing source.

Janet 1.3.1

Mostly fixing bugs from 1.3.1, but also extends the length function and basic arithmetic and comparison functions to abstract types. This lets built in integer types behave more like normal numbers, and typed arrays behave more like normal arrays.

• Fix some linking issues when creating executables with native dependencies.
• jpm now runs each test script in a new interpreter.
• Fix an issue that prevent some valid programs from compiling.
• Add mean to core.
• Abstract types that implement the :+, :-, :*, :/, :>, :==, :<,
  :<=, and :>= methods will work with the corresponding built-in
  arithmetic functions. This means built-in integer types can now be used as
  normal number values in many contexts.
• Allow (length x) on typed arrays an other abstract types that implement
  the :length method.