1.0.0-alpha.13 (2025-09-20)

    Enhancements
      - Improved memory management:
          - SML signal handler functions are changed to help avoid reference
             cycles involving GObject instances, which can prevent unreachable
             GObject instances from being destroyed.
          - SML finalization of unreachable GObject instances no longer assumes
             GObject destruction is thread-safe, avoiding potential failures.
      - Added function `GLib.MainContext.invoke`.
      - Added support for GObject weak references.  A new special structure
         `Weak` provides a type-safe interface to GObject weak references.  The
         new structure `GObject.WeakRef` provides the API from the GIR metadata.
      - Improved debugging diagnostic output that reports all memory operations.
      - Combined debug environment variables into one called GIRAFFE_DEBUG.
      - Makefile uses DESTDIR as the prefix for each installed target file, to
         support staged installs.
      - The configure utility no longer accepts --prefix with a relative path
         argument.

    Breaking changes
      - SML signal handler functions take the object instance that emits the
         signal as an additional curried argument.  This argument should be used
         to refer to the emitting object in the handler function to avoid
         reference cycles involving foreign objects.  For more information, see
         the User Guide section on Memory Management.  The introduction of the
         new argument requires every handler function to be updated, which will
         be identified by type checking failures where the handler function is
         used as an argument of new argument of `[Child]Signal.connect[After]`.
      - SML finalization (and, possibly, destruction) of GObject instances found
         unreachable by GC no longer occurs asynchronously unless explicitly
         enabled.  This can be enabled by evaluating
             Giraffe.Finalize.enableAsyncInContext NONE NONE
         typically, before the default main context is run.  Existing code will
         continue to compile and run without asynchronous SML finalization.  For
         more information, see the User Guide section on [Memory Management]
         (https://giraffelibrary.org/ug-memory-management.html).
      - The module ValueAccessor is no longer included with the GObject
         namespace.  The (identical) module ValueAccessor is still included with
         the GLib namespace and this must now be used.  This may require a
         dependency on `glib-2.0` to be added in MLB files.
      - The structures GC, GiraffeLog and GiraffeDebug no longer exist at the
         top-level and have been moved inside the structure Giraffe as follows:
            `GC`           ---> `Giraffe.GC`
            `GiraffeLog`   ---> `Giraffe.Log`
            `GiraffeDebug` ---> `Giraffe.Debug`
         Existing references to these structures may need to be changed as
         above.
      - `GLib.Source.t` constructor functions take a callback function argument.
         In C, `g_source_set_callback` is used to set the callback function of a
         source after it has been created.  The type of the callback function
         varies so this API cannot be carried over to SML whilst maintaining
         type safety.  The SML functions that construct a new kind of source now
         take the callback function for the source.  The signature G_LIB now
         specifies:
            val childWatchSourceNew : Pid.t * ChildWatchFunc.t -> SourceRecord.t
            val idleSourceNew : SourceFunc.t -> SourceRecord.t
            val timeoutSourceNew : LargeInt.int * SourceFunc.t -> SourceRecord.t
            val timeoutSourceNewSeconds
                                 : LargeInt.int * SourceFunc.t -> SourceRecord.t
         Previously, these functions were effectively useless because a callback
         could not be set after a source was created, so this change should not
         affect existing code.
      - MLton 20130715 no longer supported.

    Bug fixes
      - MLton-specific fixes:
          - The MLton import attribute `reentrant` is specified by default in
             bindings to API functions because the SML runtime can be re-entered
             via a callback for most API functions.
      - Fixed include paths in supporting C library files that caused a build
         failure on some platforms.
      - Fixed dependence on GDesktopAppInfo in supporting C library files
         causing a build failure on some platforms.
      - Fixed memory management issue causing occasional failure when using an
         object via an `as<Iface>` function.
      - Remove suggested C compiler option -std=c99 in MLton build documentation
         as this may causes compilation with MLton to fail on some platforms.


1.0.0-alpha.12 (2021-11-28)

  - Changed function names in the module Signal to align with GIR metadata:
        `Signal.disconnect`  ---> `Signal.handlerDisconnect`
        `Signal.isConnected` ---> `Signal.handlerIsConnected`
  - Changed type names in the module Signal:
        `Signal.id` --->  `Signal.handler_id`
  - Poly/ML 5.8.2 supported.  Note that Poly/ML >= 5.8.2 does not use libffi.
  - Poly/ML-specific changes:
      - Dynamic linking used for versions of Poly/ML >= 5.8.  Earlier versions
         do not support dynamic linking and dynamic loading is still used.
  - MLton-specific changes:
      - Added `deadCode` annotation to MLB files to reduce compilation times.
  - Updated internal representation of C size types to avoid unnecessary
     internal conversions and checks.  This representation is compatible with
     LLP64 systems (such as Windows 64 bit).  Also, this reduces the size of
     binaries, significantly for Poly/ML.
  - Added support for specifying signal detail.
  - Added support for emitting a signal.
  - Added support for blocking and unblocking a signal handler.
  - Added signal conversion function `Signal.conv` to convert a signal of
     an interface to a signal of a class or interface that implements the
     interface.
  - Fixed loss of property type safety where SML type checking did not ensure
     that access to a property was allowed only for an object with the property.


1.0.0-alpha.11 (2021-02-10)

  - Changed functions `[Child]Signal.connect[After]` to take signal and handler
     arguments as a pair, e.g. `Signal.connect <obj> (<aSig>, <handlerFun>)`.
  - Renamed signature `UTF8` to `UTF_8`.
  - MLton 20180207 supported, retaining support for MLton 20130715 by applying
     the following changes to versions after 20130715:
      - Specified import attribute `reentrant` as required to avoid seg. faults.
      - Added `valrecConstr ignore` annotation to MLB files to avoid warnings.
  - Updated library versions:
        GLib 2.0            2.66.4
        GIRepository 2.0    1.66.1
        Atk 1.0             2.36.0
        Pango 1.0           1.48.0
        GdkPixbuf 2.0       2.40.0
        GTK 3.0             3.24.24
        GtkSourceView 3.0   3.24.11
        Vte 2.91            0.62.1
  - Added `Cairo.Context` functions except functions involving the C types
     `cairo_rectangle_list_t` and `cairo_path_t`.
  - Fixed `Giraffe.exit` to release ownership of C objects and memory on exit.
  - Improved installation:
      - Source files installed for only requested compilers.


1.0.0-alpha.10 (2020-11-23)

  - Fixed build for GLib >= 2.62.0.
  - Updated configure script to check for MLton include directory under lib64.


1.0.0-alpha.9 (2020-11-15)

  - Updated representation of properties, which changes the way properties
     are accessed as follows:
        `#get <a>Prop`  --->  `Property.get <a>Prop`
        `#set <a>Prop`  --->  `Property.set <a>Prop`
        `#new <a>Prop`  --->  `Property.init <a>Prop`
  - Added bind functions to the module `Property` that provide a type-safe
     interface for binding properties.
  - Added support for accessing fields of a record.
  - Added support for constructing value-like records: for a value-like record
     <R> with no private fields, a function `<R>.new` is generated if no
     function of the same name already exists.
  - SML type for a non-string C array type made abstract as follows:
      - For each C array type, where the SML type of the C element type is
         `<Elem>.t`, the following modules are declared if referenced:
            `structure <Elem>CArray     : C_ARRAY`
            `structure <Elem>CArrayN    : C_ARRAY_N`
            `structure <Elem>CPtrArray  : C_ARRAY`
            `structure <Elem>CPtrArrayN : C_ARRAY_N`
      - The abstract SML type is `<Elem>C[Ptr]Array[N].t` and represents a
         C array as follows:

            C array                                   size
                                      zero terminated      separate parameter

                      packed inline   <Elem>CArray.t       <Elem>CArrayN.t
            elements
                      referenced by   <Elem>CPtrArray.t    <Elem>CPtrArrayN.t
                      a pointer

     (The change in array representation avoids performance issues with large
     arrays by allowing the internal representation to be a C array allocated
     on the C heap that is not necessarily converted to/from an SML value.)
  - SML type for C integer types `gsize` and `gssize` changed from
     `LargeInt.int` to `int`.
  - Added a function that returns the instance type to root classes:
      - `GObject.ObjectClass.instanceType`
      - `GObject.ParamSpecClass.instanceType`
  - Removed bespoke version of `GLib.childWatchSourceNew` that was added
     manually.
  - Fixed introspection metadata for the following functions, which now return
     an optional value:
      - `Gio.InetAddress.newFromString`
      - `Gio.InetSocketAddress.newFromString`
  - Fixed introspection metadata for the following functions, which now return
     a new buffer:
      - `GLib.IOChannel.readChars`
      - `Gio.InputStream.read`
  - Added module Giraffe with functions `exit` and `error`.
  - Updated top-level function `use` to support references to environment
     variables using the notation `$(<var>)` for the value of `<var>`.
  - Updated code generation to use nullable attribute of 'out' and 'inout'
     arguments to determine whether an optional type is used.  With the
     exception of arrays with a size parameter or fixed size zero (which may be
     null when empty), an optional type is used iff nullable is specified.
  - Poly/ML-specific changes:
      - A callback no longer leaks memory.  (A closure, which cannot be freed,
         is now allocated for each callback type only, not for each callback
         instance, following the approach already used for MLton.)
  - Fixed an unlikely but theoretically possible issue where memory for a
     function argument could be freed immediately on returning from the function
     call (because the last use of the memory was for the function argument) but
     some of the memory is referenced in the value passed back from an 'out' or
     'inout' argument and needs to be copied after returning from the call.


1.0.0-alpha.8 (2018-10-17)

  - Removed restriction on Poly/ML 5.7 that required C function argument/return
     values with a C integer type to be in the range of `Int.int` which, in
     practice, required `Int` to be the same as `IntInf`.
  - Generated C wrapper functions for use with MLton so all functions supported.
  - Generated C functions to determine the size of value-like records.
  - Updated library versions:
        GLib 2.0            2.50.3
        GIRepository 2.0    1.50.0
        Atk 1.0             2.22.0
        Pango 1.0           1.40.9
        GdkPixbuf 2.0       2.36.9
        GTK+ 3.0            3.22.17
        GtkSourceView 3.0   3.22.2
        Vte 2.90            0.36.5
        Vte 2.91            0.46.3
  - Included deprecated functions in generated code.
  - GLib namespace is loaded before GObject namespace.
  - Added `GObject.Object.new`.
  - Fixed property operators to respect construct-only mode.
  - Supported case-insensitive file systems.
  - Fixed use of dynamic loader with Poly/ML under Darwin.


1.0.0-alpha.7 (2017-10-18)

  - Poly/ML 5.6 required.
  - Poly/ML 5.7 supported.
  - Poly/ML-specific changes:
      - Introduced finalizers based on weak references.
      - Used the new FFI (provided by the structure Foreign).
  - MLton-specific changes:
      - Added required MLton annotations to Giraffe library MLB files.
  - Added support for C array types.
  - Updated support for object types.  For a class C, object types are changed
     as follows:
        `'a <C>Class.t `  --->  `'a <C>Class.class`
        <none>            --->  `   <C>Class.t    `  (new local type)
        `'a <C>.class_t`  --->  `'a <C>.class     `
        `   <C>.t      `  <-->  `   <C>.t         `  (no change)
  - Added support for structure types.  (Previously, a limited number of record
     modules were created manually.)  For a record R, structure type
     `<R>.record_t` has been removed.
  - Added remaining parts of namespaces that can be supported.
  - Changed type names in the module Signal:
        `Signal.signal`     --->  `Signal.t`
        `Signal.signal_id`  --->  `Signal.id`
  - Generated codegen log in file 'excluded-log.page'.
  - Used non-option type for 'out' parameters conditional on error and ignored
     boolean return value if it indicates an error.


1.0.0-alpha.6 (2015-09-16)

  - Added type abbreviation for object and structure types:
      - for class C, object type `C.t` is equivalent to `base C.class_t`
      - for record R, structure type `R.t` is equivalent to `R.record_t`
  - Changed naming convention for types and constructors to use underscores
     between words in line with the Basis Library convention.
  - Changed Gdk button event names in line with GTK+ as follows:
      - `TWOBUTTONPRESS`   changed to `DOUBLE_BUTTON_PRESS`
      - `THREEBUTTONPRESS` changed to `TRIPLE_BUTTON_PRESS`
  - Removed experimental type-safe interface to style properties.  Style
     properties must be accessed via `GObject.Value` which is not type-safe.


1.0.0-alpha.5 (2015-05-29)

  - Added support for Darwin (Mac OS X).
  - Poly/ML 5.5.2 required.
  - Improved installation:
      - scripts compatible with Dash and Bash 3
      - further configure options and checks
      - corrections to file 'Makefile'
  - config.mk file installed to provide configuration to applications.
  - Archive (A) files built for MLton C libraries instead of object (O) files.
  - Fixed bugs in C libraries and turned on C compiler warnings.
  - Changed runtime licence to LGPL v2.1.


1.0.0-alpha.4 (2015-02-08)

  - Added support for multiple versions of a library.
  - Added library vte-2.91.
  - Restructured source code directories.
  - Introduced configure script for installation.


1.0.0-alpha.3 (2014-12-19)

  - SML generated from GIR files:
      - no longer platform-specific
      - alias types included
  - Added support for Pango and GtkSourceView libraries.
  - `Pid.t` moved to `GLib.Pid.t`
  - FFI module for basic types restructured.


1.0.0-alpha.2 (2012-10-29)


1.0.0-alpha.1 (2012-10-12)
