diff --git a/src/Moniker.Cli/Program.cs b/src/Moniker.Cli/Program.cs
index 90fea1a..3a77818 100644
--- a/src/Moniker.Cli/Program.cs
+++ b/src/Moniker.Cli/Program.cs
@@ -1,43 +1,42 @@
 using JetBrains.Annotations;
 using McMaster.Extensions.CommandLineUtils;
 
-namespace Moniker.Cli
+namespace Moniker.Cli;
+
+[Command(Name = "moniker", FullName = "moniker", Description = "Moniker command line interface")]
+[VersionOptionFromMember(MemberName = nameof(GetVersion))]
+internal class Program
 {
-    [Command(Name = "moniker", FullName = "moniker", Description = "Moniker command line interface")]
-    [VersionOptionFromMember(MemberName = nameof(GetVersion))]
-    internal class Program
+    private readonly IConsole _console;
+
+    public Program(IConsole console) => _console = console;
+
+    [Option("-s|--style <STYLE>",
+        "The style of moniker to generate (Moniker or Moby)",
+        CommandOptionType.SingleValue)]
+    [UsedImplicitly]
+    public MonikerStyle MonikerStyle { get; } = MonikerStyle.Moniker;
+
+    [Option("-d|--delimiter <DELIMITER>",
+        "The delimiter to use between name parts such as adjective and noun",
+        CommandOptionType.SingleValue)]
+    [UsedImplicitly]
+    public string Delimiter { get; } = NameGenerator.DefaultDelimiter;
+
+    [UsedImplicitly]
+    public int OnExecute()
     {
-        private readonly IConsole _console;
-
-        public Program(IConsole console) => _console = console;
-
-        [Option("-s|--style <STYLE>",
-            "The style of moniker to generate (Moniker or Moby)",
-            CommandOptionType.SingleValue)]
-        [UsedImplicitly]
-        public MonikerStyle MonikerStyle { get; } = MonikerStyle.Moniker;
-
-        [Option("-d|--delimiter <DELIMITER>",
-            "The delimiter to use between name parts such as adjective and noun",
-            CommandOptionType.SingleValue)]
-        [UsedImplicitly]
-        public string Delimiter { get; } = NameGenerator.DefaultDelimiter;
-
-        [UsedImplicitly]
-        public int OnExecute()
-        {
-            var moniker = NameGenerator.Generate(MonikerStyle, Delimiter);
-            _console.WriteLine(moniker);
-            return 0;
-        }
-
-        private static int Main(string[] args)
-            => CommandLineApplication.Execute<Program>(args);
-
-        private static string? GetVersion() =>
-            (string?)typeof(Program).Assembly
-                .GetType("GitVersionInformation")!
-                .GetField("FullSemVer")!
-                .GetValue(null);
+        var moniker = NameGenerator.Generate(MonikerStyle, Delimiter);
+        _console.WriteLine(moniker);
+        return 0;
     }
+
+    private static int Main(string[] args)
+        => CommandLineApplication.Execute<Program>(args);
+
+    private static string? GetVersion() =>
+        (string?)typeof(Program).Assembly
+            .GetType("GitVersionInformation")!
+            .GetField("FullSemVer")!
+            .GetValue(null);
 }
diff --git a/src/Moniker/MonikerStyle.cs b/src/Moniker/MonikerStyle.cs
index 5f6edd8..4184256 100644
--- a/src/Moniker/MonikerStyle.cs
+++ b/src/Moniker/MonikerStyle.cs
@@ -1,18 +1,17 @@
-namespace Moniker
+namespace Moniker;
+
+/// <summary>
+/// Supported styles of random names to generate.
+/// </summary>
+public enum MonikerStyle
 {
     /// <summary>
-    /// Supported styles of random names to generate.
+    /// Names found in the technosophos/moniker project.
     /// </summary>
-    public enum MonikerStyle
-    {
-        /// <summary>
-        /// Names found in the technosophos/moniker project.
-        /// </summary>
-        Moniker,
+    Moniker,
 
-        /// <summary>
-        /// Names found in the moby/moby project.
-        /// </summary>
-        Moby
-    }
+    /// <summary>
+    /// Names found in the moby/moby project.
+    /// </summary>
+    Moby
 }
diff --git a/src/Moniker/NameGenerator.cs b/src/Moniker/NameGenerator.cs
index 103a229..02d2ff3 100644
--- a/src/Moniker/NameGenerator.cs
+++ b/src/Moniker/NameGenerator.cs
@@ -2,128 +2,127 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
-namespace Moniker
+namespace Moniker;
+
+/// <summary>
+/// Generates fun random names that are readable and memorable.
+/// </summary>
+public static class NameGenerator
 {
     /// <summary>
-    /// Generates fun random names that are readable and memorable.
+    /// The default delimiter between adjective and noun.
+    /// </summary>
+    public const string DefaultDelimiter = "-";
+
+    /// <summary>
+    /// Generate a random name in the specified style.
     /// </summary>
-    public static class NameGenerator
+    /// <param name="monikerStyle">The style of random name.</param>
+    /// <param name="delimiter">An optional delimiter to use between adjective and noun.</param>
+    /// <returns>The generated random name.</returns>
+    /// <exception cref="ArgumentOutOfRangeException"></exception>
+    public static string Generate(MonikerStyle monikerStyle, string delimiter = DefaultDelimiter)
     {
-        /// <summary>
-        /// The default delimiter between adjective and noun.
-        /// </summary>
-        public const string DefaultDelimiter = "-";
-
-        /// <summary>
-        /// Generate a random name in the specified style.
-        /// </summary>
-        /// <param name="monikerStyle">The style of random name.</param>
-        /// <param name="delimiter">An optional delimiter to use between adjective and noun.</param>
-        /// <returns>The generated random name.</returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static string Generate(MonikerStyle monikerStyle, string delimiter = DefaultDelimiter)
-        {
-            ValidateDelimiterArgument(delimiter);
-            Generate(monikerStyle, out var adjective, out var noun);
-            return Join(adjective, delimiter, noun);
-        }
+        ValidateDelimiterArgument(delimiter);
+        Generate(monikerStyle, out var adjective, out var noun);
+        return Join(adjective, delimiter, noun);
+    }
 
-        /// <summary>
-        /// Generate a random name in the specified style.
-        /// </summary>
-        /// <param name="monikerStyle">The style of random name.</param>
-        /// <param name="adjective">The adjective part of the random name.</param>
-        /// <param name="noun">The noun part of the random name.</param>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static void Generate(MonikerStyle monikerStyle, out Chars adjective, out Chars noun)
+    /// <summary>
+    /// Generate a random name in the specified style.
+    /// </summary>
+    /// <param name="monikerStyle">The style of random name.</param>
+    /// <param name="adjective">The adjective part of the random name.</param>
+    /// <param name="noun">The noun part of the random name.</param>
+    /// <exception cref="ArgumentOutOfRangeException"></exception>
+    public static void Generate(MonikerStyle monikerStyle, out Chars adjective, out Chars noun)
+    {
+        switch (monikerStyle)
         {
-            switch (monikerStyle)
-            {
-                case MonikerStyle.Moby: GenerateMoby(out adjective, out noun); break;
-                case MonikerStyle.Moniker: GenerateMoniker(out adjective, out noun); break;
-                default: throw new ArgumentOutOfRangeException(nameof(monikerStyle));
-            }
+            case MonikerStyle.Moby: GenerateMoby(out adjective, out noun); break;
+            case MonikerStyle.Moniker: GenerateMoniker(out adjective, out noun); break;
+            default: throw new ArgumentOutOfRangeException(nameof(monikerStyle));
         }
+    }
 
-        /// <summary>
-        /// Generate a random name in the 'moniker' project style.
-        /// </summary>
-        /// <param name="delimiter">An optional delimiter to use between adjective and noun.</param>
-        /// <returns>The generated random name.</returns>
-        public static string GenerateMoniker(string delimiter = DefaultDelimiter)
-        {
-            ValidateDelimiterArgument(delimiter);
-            GenerateMoniker(out var adjective, out var noun);
-            return Join(adjective, delimiter, noun);
-        }
+    /// <summary>
+    /// Generate a random name in the 'moniker' project style.
+    /// </summary>
+    /// <param name="delimiter">An optional delimiter to use between adjective and noun.</param>
+    /// <returns>The generated random name.</returns>
+    public static string GenerateMoniker(string delimiter = DefaultDelimiter)
+    {
+        ValidateDelimiterArgument(delimiter);
+        GenerateMoniker(out var adjective, out var noun);
+        return Join(adjective, delimiter, noun);
+    }
 
-        /// <summary>
-        /// Generate a random name in the 'moniker' project style.
-        /// </summary>
-        /// <param name="adjective">The adjective part of the random name.</param>
-        /// <param name="noun">The noun part of the random name.</param>
-        public static void GenerateMoniker(out Chars adjective, out Chars noun)
-            => BuildNamePair(MonikerDescriptors.Strings, out adjective, MonikerAnimals.Strings, out noun);
-
-        /// <summary>
-        /// Generate a random name in the 'moby' project style.
-        /// </summary>
-        /// <param name="delimiter">An optional delimiter to use between adjective and noun.</param>
-        /// <returns>The generated random name.</returns>
-        public static string GenerateMoby(string delimiter = DefaultDelimiter)
-        {
-            ValidateDelimiterArgument(delimiter);
-            GenerateMoby(out var adjective, out var noun);
-            return Join(adjective, delimiter, noun);
-        }
+    /// <summary>
+    /// Generate a random name in the 'moniker' project style.
+    /// </summary>
+    /// <param name="adjective">The adjective part of the random name.</param>
+    /// <param name="noun">The noun part of the random name.</param>
+    public static void GenerateMoniker(out Chars adjective, out Chars noun)
+        => BuildNamePair(MonikerDescriptors.Strings, out adjective, MonikerAnimals.Strings, out noun);
 
-        /// <summary>
-        /// Generate a random name in the 'moby' project style.
-        /// </summary>
-        /// <returns>The generated random name.</returns>
-        public static void GenerateMoby(out Chars adjective, out Chars noun)
-            => BuildNamePair(MobyAdjectives.Strings, out adjective, MobySurnames.Strings, out noun);
+    /// <summary>
+    /// Generate a random name in the 'moby' project style.
+    /// </summary>
+    /// <param name="delimiter">An optional delimiter to use between adjective and noun.</param>
+    /// <returns>The generated random name.</returns>
+    public static string GenerateMoby(string delimiter = DefaultDelimiter)
+    {
+        ValidateDelimiterArgument(delimiter);
+        GenerateMoby(out var adjective, out var noun);
+        return Join(adjective, delimiter, noun);
+    }
 
-        private static void ValidateDelimiterArgument(
-            string delimiter,
-            [CallerArgumentExpression(nameof(delimiter))] string? paramName = null)
-        {
-            if (string.IsNullOrEmpty(delimiter))
-                throw new ArgumentException("The delimiter must not be null or empty.", paramName);
-        }
+    /// <summary>
+    /// Generate a random name in the 'moby' project style.
+    /// </summary>
+    /// <returns>The generated random name.</returns>
+    public static void GenerateMoby(out Chars adjective, out Chars noun)
+        => BuildNamePair(MobyAdjectives.Strings, out adjective, MobySurnames.Strings, out noun);
 
-        private static void BuildNamePair(
-            Utf8Strings adjectives, out Chars adjective,
-            Utf8Strings nouns, out Chars noun)
-        {
-            do
-            {
-                adjective = GetRandomEntry(adjectives);
-                noun = GetRandomEntry(nouns);
-            }
-            while (adjective.Equals("boring"u8) && noun.Equals("wozniak"u8)); // Steve Wozniak is not boring
-        }
+    private static void ValidateDelimiterArgument(
+        string delimiter,
+        [CallerArgumentExpression(nameof(delimiter))] string? paramName = null)
+    {
+        if (string.IsNullOrEmpty(delimiter))
+            throw new ArgumentException("The delimiter must not be null or empty.", paramName);
+    }
 
-        private static Chars GetRandomEntry(Utf8Strings entries)
+    private static void BuildNamePair(
+        Utf8Strings adjectives, out Chars adjective,
+        Utf8Strings nouns, out Chars noun)
+    {
+        do
         {
-            var index = Random.Shared.Next(entries.Count);
-            return entries[index];
+            adjective = GetRandomEntry(adjectives);
+            noun = GetRandomEntry(nouns);
         }
+        while (adjective.Equals("boring"u8) && noun.Equals("wozniak"u8)); // Steve Wozniak is not boring
+    }
 
-        private static string Join(Chars adjective, ReadOnlySpan<char> delimiter, Chars noun)
-        {
-            var length = adjective.Length + delimiter.Length + noun.Length;
-            var chars = length <= 64 ? stackalloc char[length] : new char[length];
+    private static Chars GetRandomEntry(Utf8Strings entries)
+    {
+        var index = Random.Shared.Next(entries.Count);
+        return entries[index];
+    }
 
-            var writeCount = adjective.Write(chars);
-            Debug.Assert(writeCount == adjective.Length);
+    private static string Join(Chars adjective, ReadOnlySpan<char> delimiter, Chars noun)
+    {
+        var length = adjective.Length + delimiter.Length + noun.Length;
+        var chars = length <= 64 ? stackalloc char[length] : new char[length];
 
-            delimiter.CopyTo(chars[adjective.Length..]);
+        var writeCount = adjective.Write(chars);
+        Debug.Assert(writeCount == adjective.Length);
 
-            writeCount = noun.Write(chars[(adjective.Length + delimiter.Length)..]);
-            Debug.Assert(writeCount == noun.Length);
+        delimiter.CopyTo(chars[adjective.Length..]);
 
-            return new(chars);
-        }
+        writeCount = noun.Write(chars[(adjective.Length + delimiter.Length)..]);
+        Debug.Assert(writeCount == noun.Length);
+
+        return new(chars);
     }
 }
diff --git a/src/Moniker/Utf8Strings.cs b/src/Moniker/Utf8Strings.cs
index e93c563..b677eed 100644
--- a/src/Moniker/Utf8Strings.cs
+++ b/src/Moniker/Utf8Strings.cs
@@ -1,8 +1,5 @@
-#nullable enable
-
-using System;
+using System;
 using System.Diagnostics;
-using System.Text;
 
 namespace Moniker;
 
@@ -41,7 +38,7 @@ public ref struct Enumerator(Utf8Strings strings)
         /// Behaviour is undefined if <see cref="MoveNext"/> has never been called or returned
         /// <see langword="false"/>.
         /// </remarks>
-        public Chars Current => _strings[_index];
+        public readonly Chars Current => _strings[_index];
 
         public bool MoveNext()
         {
diff --git a/test/Moniker.Tests/CharsTests.cs b/test/Moniker.Tests/CharsTests.cs
index b9edc6c..f0b12c2 100644
--- a/test/Moniker.Tests/CharsTests.cs
+++ b/test/Moniker.Tests/CharsTests.cs
@@ -1,6 +1,6 @@
-using System.Text;
-using System;
+using System;
 using System.Linq;
+using System.Text;
 using FluentAssertions;
 using Xunit;
 
diff --git a/test/Moniker.Tests/NameGeneratorTests.cs b/test/Moniker.Tests/NameGeneratorTests.cs
index 6517352..b349d6a 100644
--- a/test/Moniker.Tests/NameGeneratorTests.cs
+++ b/test/Moniker.Tests/NameGeneratorTests.cs
@@ -2,84 +2,83 @@
 using FluentAssertions;
 using Xunit;
 
-namespace Moniker.Tests
+namespace Moniker.Tests;
+
+public class NameGeneratorTests
 {
-    public class NameGeneratorTests
+    [Theory]
+    [InlineData(MonikerStyle.Moby, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
+    [InlineData(MonikerStyle.Moby, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
+    [InlineData(MonikerStyle.Moniker, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
+    [InlineData(MonikerStyle.Moniker, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
+    public void GenerateWithSpecificMonikerStyleMethods(
+        MonikerStyle monikerStyle,
+        string separator,
+        string expected)
     {
-        [Theory]
-        [InlineData(MonikerStyle.Moby, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
-        [InlineData(MonikerStyle.Moby, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
-        [InlineData(MonikerStyle.Moniker, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
-        [InlineData(MonikerStyle.Moniker, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
-        public void GenerateWithSpecificMonikerStyleMethods(
-            MonikerStyle monikerStyle,
-            string separator,
-            string expected)
+        string moniker;
+        switch (monikerStyle)
         {
-            string moniker;
-            switch (monikerStyle)
-            {
-                case MonikerStyle.Moniker:
-                    moniker = separator == null 
-                        ? NameGenerator.GenerateMoniker()
-                        : NameGenerator.GenerateMoniker(separator);
-                    break;
-                case MonikerStyle.Moby:
-                    moniker = separator == null
-                        ? NameGenerator.GenerateMoby()
-                        : NameGenerator.GenerateMoby(separator);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(monikerStyle), monikerStyle, null);
-            }
-
-            moniker.Should().MatchRegex(expected);
+            case MonikerStyle.Moniker:
+                moniker = separator == null 
+                    ? NameGenerator.GenerateMoniker()
+                    : NameGenerator.GenerateMoniker(separator);
+                break;
+            case MonikerStyle.Moby:
+                moniker = separator == null
+                    ? NameGenerator.GenerateMoby()
+                    : NameGenerator.GenerateMoby(separator);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(monikerStyle), monikerStyle, null);
         }
 
-        [Theory]
-        [InlineData(MonikerStyle.Moby, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
-        [InlineData(MonikerStyle.Moby, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
-        [InlineData(MonikerStyle.Moniker, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
-        [InlineData(MonikerStyle.Moniker, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
-        public void GenerateWithMonikerStyleParameter(
-            MonikerStyle monikerStyle,
-            string separator,
-            string expected)
-        {
-            var moniker = separator == null
-                ? NameGenerator.Generate(monikerStyle)
-                : NameGenerator.Generate(monikerStyle, separator);
+        moniker.Should().MatchRegex(expected);
+    }
 
-            moniker.Should().MatchRegex(expected);
-        }
+    [Theory]
+    [InlineData(MonikerStyle.Moby, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
+    [InlineData(MonikerStyle.Moby, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
+    [InlineData(MonikerStyle.Moniker, null, "[a-zA-Z]+\x2D[a-zA-Z]+")]
+    [InlineData(MonikerStyle.Moniker, "_", "[a-zA-Z]+\x5F[a-zA-Z]+")]
+    public void GenerateWithMonikerStyleParameter(
+        MonikerStyle monikerStyle,
+        string separator,
+        string expected)
+    {
+        var moniker = separator == null
+            ? NameGenerator.Generate(monikerStyle)
+            : NameGenerator.Generate(monikerStyle, separator);
 
-        [Theory]
-        [InlineData(MonikerStyle.Moby)]
-        [InlineData(MonikerStyle.Moniker)]
-        public void GeneratePairWithSpecificMonikerStyleMethods(MonikerStyle monikerStyle)
-        {
-            Chars adjective, noun;
+        moniker.Should().MatchRegex(expected);
+    }
 
-            switch (monikerStyle)
-            {
-                case MonikerStyle.Moniker: NameGenerator.GenerateMoniker(out adjective, out noun); break;
-                case MonikerStyle.Moby: NameGenerator.GenerateMoby(out adjective, out noun); break;
-                default: throw new ArgumentOutOfRangeException(nameof(monikerStyle), monikerStyle, null);
-            };
-            const string expected = /* lang=regex */ "^[a-zA-Z]+$";
-            adjective.ToString().Should().MatchRegex(expected);
-            noun.ToString().Should().MatchRegex(expected);
-        }
+    [Theory]
+    [InlineData(MonikerStyle.Moby)]
+    [InlineData(MonikerStyle.Moniker)]
+    public void GeneratePairWithSpecificMonikerStyleMethods(MonikerStyle monikerStyle)
+    {
+        Chars adjective, noun;
 
-        [Theory]
-        [InlineData(MonikerStyle.Moby)]
-        [InlineData(MonikerStyle.Moniker)]
-        public void GeneratePairWithMonikerStyleParameter(MonikerStyle monikerStyle)
+        switch (monikerStyle)
         {
-            NameGenerator.Generate(monikerStyle, out var adjective, out var noun);
-            const string expected = /* lang=regex */ "^[a-zA-Z]+$";
-            adjective.ToString().Should().MatchRegex(expected);
-            noun.ToString().Should().MatchRegex(expected);
-        }
+            case MonikerStyle.Moniker: NameGenerator.GenerateMoniker(out adjective, out noun); break;
+            case MonikerStyle.Moby: NameGenerator.GenerateMoby(out adjective, out noun); break;
+            default: throw new ArgumentOutOfRangeException(nameof(monikerStyle), monikerStyle, null);
+        };
+        const string expected = /* lang=regex */ "^[a-zA-Z]+$";
+        adjective.ToString().Should().MatchRegex(expected);
+        noun.ToString().Should().MatchRegex(expected);
+    }
+
+    [Theory]
+    [InlineData(MonikerStyle.Moby)]
+    [InlineData(MonikerStyle.Moniker)]
+    public void GeneratePairWithMonikerStyleParameter(MonikerStyle monikerStyle)
+    {
+        NameGenerator.Generate(monikerStyle, out var adjective, out var noun);
+        const string expected = /* lang=regex */ "^[a-zA-Z]+$";
+        adjective.ToString().Should().MatchRegex(expected);
+        noun.ToString().Should().MatchRegex(expected);
     }
 }
diff --git a/test/Moniker.Tests/StringDataTests.cs b/test/Moniker.Tests/StringDataTests.cs
index 25887d2..8c86814 100644
--- a/test/Moniker.Tests/StringDataTests.cs
+++ b/test/Moniker.Tests/StringDataTests.cs
@@ -1,9 +1,7 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
 using FluentAssertions;
 using Xunit;