basesystems: Implements encoders/decoders for basesystems

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

Warnings:

[missing-upper-bounds] On library, these packages miss upper bounds: - bytestring Please add them. There is more information at https://pvp.haskell.org/

This package implements encoder and decoder methods for numeric basesystems and provides definitions for common basesystems like base16, base58btc, base64, and more.

[Skip to Readme]

Properties

Versions	1.0.0.0, 1.0.0.1, 1.0.1.0
Change log	CHANGE_LOG.md
Dependencies	array (>=0.5 && <0.6), base (>=4.18 && <5), bytestring (>=0.12), containers (>=0.7 && <8), text (>=2.1 && <2.2) [details]
License	BSD-3-Clause
Author	Zoey McBride
Maintainer	zoeymcbride@mailbox.org
Category	Numeric, Data, Serialization
Source repo	head: git clone https://git.sr.ht/~z0/basesystems
Uploaded	by z0 at 2026-05-07T21:09:09Z

Modules

[Index] [Quick Jump]

Data
- Data.BaseSystem
- Data.BaseSystems

Flags

Manual Flags

Name	Description	Default
ci	CI Build options	Disabled
dev	Developer build options	Disabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

basesystems-1.0.1.0.tar.gz [browse] (Cabal source package)
Package description (as included in the package)

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

edit package information

Readme for basesystems-1.0.1.0

[back to package description]

basesystems

This project code contains for Encoding/Decoding number basesystems in Haskell. It's implemented in a strategy pattern style where BaseSystem is a type-class which provides the encoder and decoder methods:

class BaseSystem a where
  encoder :: a -> ByteString -> String
  decoder :: a -> String -> Maybe ByteString

Then we define data structure representations for a and implement each method with the data from a. For instance, this is how the implementations of base64 and base10 are distinguished.

Example

ghci> import Data.BaseSystem
ghci> import Data.BaseSystems
ghci> import Data.BaseSystem.Internal (packInteger)
ghci>
ghci> encoder base10 (packInteger 123) -- "123"
ghci> decoder base10 "123"             -- Just <123 as binary in ByteString>
ghci> encoder base64 (packInteger 123) -- "ew=="
ghci> decoder base64 "ew=="            -- Just <123 as binary in ByteString>

Coverage

This project aims to eventually implement most if not all of the mulitbase specification's basesytems list.

Currently, the following basesystems are supported:

base2
base10
base16(upper/lower)
base32(upper/lower) w/pad + nopad
base32hex(lower/upper) w/pad + nopad
base58btc
base64 w/pad + nopad
base64url w/pad + nopad

Unit testing can be found in the main ipfshs repo (https://git.sr.ht/~z0/ipfshs), and bugs can be reported to the ipfshs ticket tracker (https://todo.sr.ht/~z0/ipfshs).

License

This project is free software and is provided under the BSD 3-clause licensing agreement.