(patch) initial, complete, hex implementation

.forgejo/workflows/pull_request.yaml

@@ -0,0 +1,52 @@
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  library_snapshot:
+    runs-on: docker
+    container:
+      image: registry.garrity.co:8443/gs/ci-scala:latest
+    name: 'Build and Test Library Snapshot'
+    env:
+      GS_MAVEN_USER: ${{ vars.GS_MAVEN_USER }}
+      GS_MAVEN_TOKEN: ${{ secrets.GS_MAVEN_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        name: 'Checkout Repository'
+        with:
+          fetch-depth: 0
+      - name: 'Pre-Commit'
+        run: |
+          pre-commit install
+          pre-commit run --all-files
+      - name: 'Prepare Versioned Build'
+        run: |
+          latest_git_tag="$(git describe --tags --abbrev=0 || echo 'No Tags')"
+          latest_commit_message="$(git show -s --format=%s HEAD)"
+          if [[ "$latest_commit_message" == *"(major)"* ]]; then
+              export GS_RELEASE_TYPE="major"
+          elif [[ "$latest_commit_message" == *"(minor)"* ]]; then
+              export GS_RELEASE_TYPE="minor"
+          elif [[ "$latest_commit_message" == *"(patch)"* ]]; then
+              export GS_RELEASE_TYPE="patch"
+          else
+              export GS_RELEASE_TYPE="patch"
+          fi
+          echo "Previous Git Tag: $latest_git_tag"
+          echo "Latest Commit: $latest_commit_message ($GS_RELEASE_TYPE) (SNAPSHOT)"
+          sbtn -Dsnapshot=true -Drelease="$GS_RELEASE_TYPE" semVerInfo
+      - name: 'Unit Tests and Code Coverage'
+        run: |
+          sbtn clean
+          sbtn coverage
+          sbtn test
+          sbtn coverageReport
+      - name: 'Publish Snapshot'
+        run: |
+          sbtn clean
+          sbtn publish

.forgejo/workflows/release.yaml

@@ -0,0 +1,60 @@
+on:
+  push:
+    branches:
+      - main
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  library_release:
+    runs-on: docker
+    container:
+      image: registry.garrity.co:8443/gs/ci-scala:latest
+    name: 'Build and Release Library'
+    env:
+      GS_MAVEN_USER: ${{ vars.GS_MAVEN_USER }}
+      GS_MAVEN_TOKEN: ${{ secrets.GS_MAVEN_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        name: 'Checkout Repository'
+        with:
+          fetch-depth: 0
+      - name: 'Pre-Commit'
+        run: |
+          pre-commit install
+          pre-commit run --all-files
+      - name: 'Prepare Versioned Build'
+        run: |
+          latest_git_tag="$(git describe --tags --abbrev=0 || echo 'No Tags')"
+          latest_commit_message="$(git show -s --format=%s HEAD)"
+          if [[ "$latest_commit_message" == *"(major)"* ]]; then
+              export GS_RELEASE_TYPE="major"
+          elif [[ "$latest_commit_message" == *"(minor)"* ]]; then
+              export GS_RELEASE_TYPE="minor"
+          elif [[ "$latest_commit_message" == *"(patch)"* ]]; then
+              export GS_RELEASE_TYPE="patch"
+          else
+              export GS_RELEASE_TYPE="patch"
+          fi
+          echo "Previous Git Tag: $latest_git_tag"
+          echo "Latest Commit: $latest_commit_message"
+          echo "Selected Release Type: '$GS_RELEASE_TYPE'"
+          sbtn -Drelease="$GS_RELEASE_TYPE" semVerInfo
+      - name: 'Unit Tests and Code Coverage'
+        run: |
+          sbtn clean
+          sbtn coverage
+          sbtn test
+          sbtn coverageReport
+      - name: 'Publish Release'
+        run: |
+          sbtn clean
+          sbtn semVerWriteVersionToFile
+          sbtn publish
+      - name: 'Create Git Tag'
+        run: |
+          selected_version="$(cat .version)"
+          git tag "$selected_version"
+          git push origin "$selected_version"

.gitignore

@@ -0,0 +1,5 @@
+target/
+project/target/
+project/project/
+modules/core/target/
+.version

.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+---
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: fix-byte-order-marker
+      - id: mixed-line-ending
+        args: ['--fix=lf']
+        description: Enforces using only 'LF' line endings.
+      - id: trailing-whitespace
+      - id: check-yaml
+  - repo: https://git.garrity.co/garrity-software/gs-pre-commit-scala
+    rev: v1.0.0
+    hooks:
+      - id: scalafmt

.scalafmt.conf

@@ -0,0 +1,72 @@
+// See: https://github.com/scalameta/scalafmt/tags for the latest tags.
+version = 3.7.17
+runner.dialect = scala3
+maxColumn = 80
+
+rewrite {
+    rules = [RedundantBraces, RedundantParens, Imports, SortModifiers]
+    imports.expand = true
+    imports.sort = scalastyle
+    redundantBraces.ifElseExpressions = true
+    redundantBraces.stringInterpolation = true
+}
+
+indent {
+    main = 2
+    callSite = 2
+    defnSite = 2
+    extendSite = 4
+    withSiteRelativeToExtends = 2
+    commaSiteRelativeToExtends = 2
+}
+
+align {
+    preset = more
+    openParenCallSite = false
+    openParenDefnSite = false
+}
+
+newlines {
+    implicitParamListModifierForce = [before,after]
+    topLevelStatementBlankLines = [
+        {
+            blanks = 1
+        }
+    ]
+    afterCurlyLambdaParams = squash
+}
+
+danglingParentheses {
+    defnSite = true
+    callSite = true
+    ctrlSite = true
+    exclude = []
+}
+
+verticalMultiline {
+    atDefnSite = true
+    arityThreshold = 2
+    newlineAfterOpenParen = true
+}
+
+comments {
+    wrap = standalone
+}
+
+docstrings {
+    style = "SpaceAsterisk"
+    oneline = unfold
+    wrap = yes
+    forceBlankLineBefore = true
+}
+
+project {
+  excludePaths = [
+    "glob:**target/**",
+    "glob:**.metals/**",
+    "glob:**.bloop/**",
+    "glob:**.bsp/**",
+    "glob:**metals.sbt",
+    "glob:**.git/**"
+  ]
+}

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,19 @@
+# gs-hex
+
+[License (Apache 2.0)](./LICENSE)
+
+Hexadecimal conversions for Scala 3. Provides support for standard types.
+
+- [Usage](#usage)
+
+## Usage
+
+This artifact is available in the Garrity Software Maven repository.
+
+```scala
+externalResolvers +=
+  "Garrity Software Releases" at "https://maven.garrity.co/releases"
+
+val GsHex: ModuleID =
+  "gs" %% "gs-hex-v0" % "0.1.0"
+```

build.sbt

@@ -0,0 +1,25 @@
+val scala3: String = "3.4.1"
+
+ThisBuild / scalaVersion  := scala3
+ThisBuild / versionScheme := Some("semver-spec")
+ThisBuild / gsProjectName := "gs-hex"
+
+// Note: Scala 3 code coverage is busted :(
+val sharedSettings = Seq(
+  scalaVersion          := scala3,
+  version               := semVerSelected.value,
+  coverageFailOnMinimum := true
+  /* coverageMinimumStmtTotal := 100, coverageMinimumBranchTotal := 100 */
+)
+
+lazy val testSettings = Seq(
+  libraryDependencies ++= Seq(
+    "org.scalameta" %% "munit" % "1.0.0-M10" % Test
+  )
+)
+
+lazy val `gs-hex` = project
+  .in(file("."))
+  .settings(sharedSettings)
+  .settings(testSettings)
+  .settings(name := s"${gsProjectName.value}-v${semVerMajor.value}")

project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.9.9

project/plugins.sbt

@@ -0,0 +1,33 @@
+def selectCredentials(): Credentials =
+  if ((Path.userHome / ".sbt" / ".credentials").exists())
+    Credentials(Path.userHome / ".sbt" / ".credentials")
+  else
+    Credentials.apply(
+      realm = "Reposilite",
+      host = "maven.garrity.co",
+      userName = sys.env
+        .get("GS_MAVEN_USER")
+        .getOrElse(
+          throw new RuntimeException(
+            "You must either provide ~/.sbt/.credentials or specify the GS_MAVEN_USER environment variable."
+          )
+        ),
+      passwd = sys.env
+        .get("GS_MAVEN_TOKEN")
+        .getOrElse(
+          throw new RuntimeException(
+            "You must either provide ~/.sbt/.credentials or specify the GS_MAVEN_TOKEN environment variable."
+          )
+        )
+    )
+
+credentials += selectCredentials()
+
+externalResolvers := Seq(
+  "Garrity Software Mirror" at "https://maven.garrity.co/releases",
+  "Garrity Software Releases" at "https://maven.garrity.co/gs"
+)
+
+addSbtPlugin("org.scoverage" % "sbt-scoverage"        % "2.0.11")
+addSbtPlugin("gs"            % "sbt-garrity-software" % "0.2.0")
+addSbtPlugin("gs"            % "sbt-gs-semver"        % "0.2.2")

src/main/scala/gs/hex/v0/Hex.scala

@@ -0,0 +1,93 @@
+package gs.hex.v0
+
+object Hex:
+
+  private val HexChars: Array[Char] = Array(
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
+    'f'
+  )
+
+  // Leverage cache to avoid operations.
+  private val Digits: Array[Int] = Array(
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1,
+    -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1
+  )
+
+  /** Convert the given raw data to a hexadecimal string.
+    *
+    * @param data
+    *   The data to convert.
+    * @return
+    *   The output hexadecimal string.
+    */
+  def toHexString(data: Array[Byte]): String =
+    var index           = 0
+    val ch: Array[Char] = new Array(data.length * 2)
+    data.foreach { byte =>
+      ch(index) = HexChars((byte & 0xf0) >> 4)
+      ch(index + 1) = HexChars(byte & 0x0f)
+      index = index + 2
+    }
+    new String(ch)
+
+  /** Convert the given hexadecimal string to a byte array.
+    *
+    * @param encoded
+    *   The hexadecimal string.
+    * @return
+    *   The encoded byte array, or nothing if the input is not a valid hex
+    *   string.
+    */
+  def fromHexString(encoded: String): Option[Array[Byte]] =
+    if encoded.isBlank() then Some(Array.empty)
+    else if encoded.length() % 2 != 0 then None
+    else
+      val size              = encoded.length() / 2
+      val data: Array[Byte] = new Array(size)
+
+      // The "base" tracks the base index for character extraction.
+      var base = 0
+
+      // The "index" tracks the byte index being updated.
+      var index = 0
+
+      // Track if calculation failed for any reason.
+      var failed = false
+
+      // Populate each byte in the destination array.
+      while !failed && index < size do
+        // Extract the relevant characters.
+        val digit1 = Digits(encoded.charAt(base).toInt)
+        val digit2 = Digits(encoded.charAt(base + 1).toInt)
+
+        if digit1 >= 0 && digit2 >= 0 then
+          // Convert to byte and assign the result.
+          data(index) = pairToByte(digit1, digit2)
+
+          index = index + 1
+          base = base + 2
+        else
+          index = size
+          failed = true
+
+      if !failed then Some(data) else None
+
+  private inline def pairToByte(
+    digit1: Int,
+    digit2: Int
+  ): Byte =
+    ((digit1 << 4) + digit2).toByte
+
+end Hex

src/main/scala/gs/hex/v0/HexDecode.scala

@@ -0,0 +1,85 @@
+package gs.hex.v0
+
+/** Type Class for decoding hexadecimal strings to some type.
+  */
+trait HexDecode[A]:
+  /** Given some hexadecimal string representing encoded data, parse that string
+    * to reconstruct that data.
+    *
+    * @param data
+    *   The encoded hexadecimal string.
+    * @return
+    *   The decoded data, or nothing if the input is invalid.
+    */
+  def fromHexString(data: String): Option[A]
+
+  extension (data: String) def fromHex(): Option[A] = fromHexString(data)
+
+object HexDecode:
+
+  /** Retrieve the [[HexDecode]] instance for the given type.
+    *
+    * @param H
+    *   The type.
+    * @return
+    *   The [[HexDecode]] instance for the given type.
+    */
+  def apply[A](
+    using
+    H: HexDecode[A]
+  ): HexDecode[A] = H
+
+  given HexDecode[Array[Byte]] = new HexDecode[Array[Byte]] {
+
+    /** @inheritDoc
+      */
+    def fromHexString(data: String): Option[Array[Byte]] =
+      Hex.fromHexString(data)
+
+  }
+
+  given HexDecode[String] = new HexDecode[String] {
+
+    /** @inheritDoc
+      */
+    def fromHexString(data: String): Option[String] =
+      Hex.fromHexString(data).map(bytes => new String(bytes))
+
+  }
+
+  given HexDecode[Boolean] = new HexDecode[Boolean] {
+
+    /** @inheritDoc
+      */
+    def fromHexString(data: String): Option[Boolean] =
+      if data == "1" then Some(true)
+      else if data == "0" then Some(false)
+      else None
+
+  }
+
+  given HexDecode[Int] = new HexDecode[Int] {
+
+    /** @inheritDoc
+      */
+    def fromHexString(data: String): Option[Int] =
+      Hex.fromHexString(data).flatMap { bytes =>
+        if bytes.length != 4 then None
+        else Some(java.nio.ByteBuffer.wrap(bytes).getInt())
+      }
+
+  }
+
+  given HexDecode[Long] = new HexDecode[Long] {
+
+    /** @inheritDoc
+      */
+    def fromHexString(data: String): Option[Long] =
+      Hex.fromHexString(data).flatMap { bytes =>
+        if bytes.length != 8 then None
+        else Some(java.nio.ByteBuffer.wrap(bytes).getLong())
+      }
+
+  }
+
+end HexDecode

src/main/scala/gs/hex/v0/HexEncode.scala

@@ -0,0 +1,74 @@
+package gs.hex.v0
+
+/** Type Class for encoding types as hexadecimal strings.
+  */
+trait HexEncode[A]:
+  /** Encode the given data as a hexadecimal string.
+    *
+    * @param data
+    *   The data to encode.
+    * @return
+    *   The encoded data.
+    */
+  def toHexString(data: A): String
+
+  extension (data: A) def toHex(): String = toHexString(data)
+
+object HexEncode:
+
+  /** Retrieve the [[HexEncode]] instance for the given type.
+    *
+    * @param H
+    *   The type.
+    * @return
+    *   The [[HexEncode]] instance for the given type.
+    */
+  def apply[A](
+    using
+    H: HexEncode[A]
+  ): HexEncode[A] = H
+
+  given HexEncode[Array[Byte]] = new HexEncode[Array[Byte]] {
+
+    /** @inheritDoc
+      */
+    def toHexString(data: Array[Byte]): String = Hex.toHexString(data)
+  }
+
+  given HexEncode[String] = new HexEncode[String] {
+
+    /** @inheritDoc
+      */
+    def toHexString(data: String): String = Hex.toHexString(data.getBytes())
+  }
+
+  given HexEncode[Boolean] = new HexEncode[Boolean] {
+
+    /** @inheritDoc
+      */
+    def toHexString(data: Boolean): String = if data then "1" else "0"
+  }
+
+  given HexEncode[Int] = new HexEncode[Int] {
+
+    /** @inheritDoc
+      */
+    def toHexString(data: Int): String =
+      val bb = java.nio.ByteBuffer.allocate(4)
+      bb.putInt(data)
+      Hex.toHexString(bb.array())
+
+  }
+
+  given HexEncode[Long] = new HexEncode[Long] {
+
+    /** @inheritDoc
+      */
+    def toHexString(data: Long): String =
+      val bb = java.nio.ByteBuffer.allocate(8)
+      bb.putLong(data)
+      Hex.toHexString(bb.array())
+
+  }
+
+end HexEncode

src/test/scala/gs/blob/v0/EncodeDecodeTests.scala

@@ -0,0 +1,106 @@
+package gs.hex.v0
+
+import java.security.SecureRandom
+import java.util.UUID
+
+class EncodeDecodeTests extends munit.FunSuite:
+
+  val Rng       = new SecureRandom()
+  val MinLength = 1
+  val MaxLength = 100
+
+  test("should encode/decode using summoners") {
+    (0 to 10).foreach { _ =>
+      val data    = randomByteArray()
+      val encoded = HexEncode[Array[Byte]].toHexString(data)
+      val decoded = HexDecode[Array[Byte]].fromHexString(encoded)
+      assert(decoded.isDefined)
+      assert(decoded.map(_.sameElements(data)).getOrElse(false))
+    }
+  }
+
+  test("should encode/decode byte arrays") {
+    (0 to 10).foreach { _ =>
+      val data    = randomByteArray()
+      val encoded = encode(data)
+      val decoded = decode[Array[Byte]](encoded)
+      assert(decoded.isDefined)
+      assert(decoded.map(_.sameElements(data)).getOrElse(false))
+    }
+  }
+
+  test("should encode/decode strings") {
+    (0 to 10).foreach { _ =>
+      val data    = UUID.randomUUID().toString()
+      val encoded = encode(data)
+      val decoded = decode[String](encoded)
+      assert(decoded == Some(data))
+    }
+  }
+
+  test("should encode/decode boolean values") {
+    val et = encode(true)
+    val dt = decode[Boolean](et)
+    assert(dt == Some(true))
+    val ef = encode(false)
+    val df = decode[Boolean](ef)
+    assert(df == Some(false))
+  }
+
+  test("should encode/decode integers") {
+    (0 to 10).foreach { _ =>
+      val data    = Rng.nextInt(9999)
+      val encoded = encode(data)
+      val decoded = decode[Int](encoded)
+      assert(decoded == Some(data))
+    }
+  }
+
+  test("should encode/decode longs") {
+    (0 to 10).foreach { _ =>
+      val data    = Rng.nextLong(9999L)
+      val encoded = encode(data)
+      val decoded = decode[Long](encoded)
+      assert(decoded == Some(data))
+    }
+  }
+
+  test("should fail to decode invalid data to byte arrays") {
+    assert(decode[Array[Byte]]("!") == None)
+  }
+
+  test("should fail to decode invalid data to strings") {
+    assert(decode[String]("!") == None)
+  }
+
+  test("should fail to decode invalid data to bools") {
+    assert(decode[Boolean]("!") == None)
+  }
+
+  test("should fail to decode invalid data to integers") {
+    assert(decode[Int]("!") == None)
+  }
+
+  test("should fail to decode invalid data to longs") {
+    assert(decode[Long]("!") == None)
+  }
+
+  private def encode[A](
+    data: A
+  )(
+    using
+    HexEncode[A]
+  ): String = data.toHex()
+
+  private def decode[A](
+    data: String
+  )(
+    using
+    HexDecode[A]
+  ): Option[A] = data.fromHex()
+
+  private def randomByteArray(): Array[Byte] =
+    val length = Rng.nextInt(MaxLength) + MinLength
+    val bytes  = new Array[Byte](length)
+    val _      = Rng.nextBytes(bytes)
+    bytes

src/test/scala/gs/blob/v0/HexTests.scala

@@ -0,0 +1,59 @@
+package gs.hex.v0
+
+import java.security.SecureRandom
+
+class HexTests extends munit.FunSuite:
+
+  val Rng       = new SecureRandom()
+  val MinLength = 1
+  val MaxLength = 100
+
+  test("should convert an empty array to the empty string") {
+    assert(Hex.toHexString(Array.empty) == "")
+  }
+
+  test("should convert an empty string to an empty array") {
+    assert(Hex.fromHexString("").map(_.toList) == Some(List.empty[Byte]))
+  }
+
+  test(
+    "(failure case) should convert a string with an uneven length to nothing"
+  ) {
+    assert(Hex.fromHexString("0") == None)
+    assert(Hex.fromHexString("000") == None)
+    assert(Hex.fromHexString("00000") == None)
+    assert(Hex.fromHexString("0000000") == None)
+    assert(Hex.fromHexString("000000000") == None)
+  }
+
+  test(
+    "(failure case) should produce nothing if invalid characters are present"
+  ) {
+    assert(Hex.fromHexString("0!") == None)
+    (0 to 255).foreach { ch =>
+      if !isValidHexChar(ch) then
+        assert(Hex.fromHexString("0" + ch.toChar.toString()) == None)
+      else ()
+    }
+  }
+
+  test("should round trip arrays of bytes") {
+    (0 to 10).foreach { _ =>
+      val originalData = randomByteArray()
+      val encoded      = Hex.toHexString(originalData)
+      val decoded      = Hex.fromHexString(encoded)
+      assert(decoded.isDefined)
+      assert(decoded.map(_.sameElements(originalData)).getOrElse(false))
+    }
+  }
+
+  private def isValidHexChar(numeral: Int): Boolean =
+    (numeral >= 48 && numeral <= 57)
+      || (numeral >= 65 && numeral <= 90)
+      || (numeral >= 97 && numeral <= 122)
+
+  private def randomByteArray(): Array[Byte] =
+    val length = Rng.nextInt(MaxLength) + MinLength
+    val bytes  = new Array[Byte](length)
+    val _      = Rng.nextBytes(bytes)
+    bytes