[`basesystems`](http://hackage.haskell.org/package/basesystems) change log:
===========================================================================
Major release 1.2
-----------------
## Version 1.2 (07-08-2026)
This version removes the functionality that the [xcodec](
ihttps://hackage.haskell.org/package/xcodec) package now provides. This change
replaces the `Data.BaseSystem.*Transcoder` modules, so they are no longer part
of this package.
The `Data.BaseSystem.*` modules has been renamed to `Data.BaseSystems.*` to
match the package name. The `Data.BaseSystem.DigitSystem` module has also been
renamed to `Data.BaseSystems.DigitSystems` to reflect the digit systems (plural)
that it exports.
The `Data.BaseSystems.DigitSystems` module is exported by the
`Data.BaseSystems`, `Data.BaseSystems.Lazy`, and `Data.BaseSystems.Strict`
packages, so that a single import change be used for simple use cases such as
showing number strings in a fixed basesystem.
Major release 1.1
-----------------
## Version 1.1 (05-17-2026)
### Cabal
- Upgrade major versions for `text` and `containers` versions.
- Add `tested-with` line for GHC 9.6.7.
- Remove the `Dev` flag.
### Builds / CI
- Use `ghcup` to install the correct Haskell tooling instead of outdated
`cabal-install` package in all CI scripts.
- Combine documentation generation and packaging into a single script that
uploads everything to a candidate hackage page.
- Add script for running the `ipfshs` unit testing package for basesystems.
### `Data.BaseSystem` module changes
- Both `encoder` and `decoder` now use `ShortByteString` as input/output instead
of `ByteString`. Also `encoder` and `decoder` now use `Text` as input/output
data instead of `String`.
### `Data.BaseSystem.Alphabet` module changes
- This module now exports the defined `Alphabet` structs.
- Alpha.Symbol is now a plain `Char`.
- Alpha.Value is now `Word32`.
### New modules
- `Data.BaseSystem.Strict` is where the basesystem encoders and decoders
used for strict `ByteString` typed data got moved to.
- `Data.BaseSystem.Lazy` provides basesystem encoders and decoders for
`LazyByteString` data.
- `Data.BaseSystem.DigitSystem` now provides the instances for used for
`BaseSystem`.
- `Data.BaseSystem.BinaryTranscoder` provides a unified type-class interface for
working with bytestring data and converting to and from bit data for numeric
values. This module is likely to become its own package in the future.
- `Data.BaseSystem.DigitTranscoder` provides generic encoders and decoders for
`BinaryTranscoder` derivied types.
### Deleted modules
- `Data.BaseSystems` got replaced by `Data.BaseSystem.DigitSystem`.
- `Data.BaseSystem.Alphabets` got merged with `Data.BaseSystem.Alphabet`.
Major release 1.0
-----------------
## Version 1.0.0.1 (04-01-2026)
This version aims to fix the issues with the hackage page and provide CI via
sourcehut builds.
- Set correct PVP bounds for cabal dependencies.
- Added CI/CD for builds.sr.ht:
* Add `.builds/nudge-parents.yml` to automatically update this submodule in
other sourcehut repositories.
* Add `.builds/upload-candidate-docs.yml` to generate and upload documentation
to Hackage.
* Add `.builds/upload-candidate-package.yml` to generate and upload a package
candidate to Hackage.
## Version 1.0.0.0 (03-12-2026)
Finally initialize this package! This version introduces the package to the
Hackage repository and the provides an interface for encoding/decoding digit
strings in several common numeric basesystems. Namely, this version provides
the following modules for processing this data:
### `Data.BaseSystem`
Provides the type-class for `BaseSystem` and the `encoder` and `decoder` methods
and generic implementations for 2 kinds of basesystems:
- `RadixSystem` for typical basesystems such as base10
- `BitwiseSystem` for special basesystems such as base64 and base32
### `Data.BaseSystems`:
Defines common basesystems using the definitions found in
`Data.BaseSystem.Alphabets`. See the project source code for the names of
currently provided implementations.
### Other modules:
- `Data.BaseSystem.Alphabet` data structure definition for basesystem digit
alphabets and methods for querying alphabet information.
- `Data.BaseSystem.Alphabets` definitions for specific digit alphabets for
implementing basesystems.
- `Data.BaseSystem.Internal` provides useful methods used across modules. For
example the `packInteger` and `bytesToInteger` provides ways to convert
Integers to ByteString and vice-versa, which is handy for GHCi and unit
tests (so that we don't have to write numbers as ByteStrings before using the
encoders or decoders).