Strongly typed identifier

Passing a strongly typed identifier throughout the layers of an example application.

C# have records which provide immutability and equality testing.^[1] The record is sealed to prevent inheritance.^[2] It overrides the built-in ToString() method.^[3]

This example implementation includes a static method which can be used to initialize a new instance with a randomly generated globally unique identifier (GUID).

/// <summary>
/// Represents a user identifier.
/// </summary>
/// <param name="Id">The user identifier.</param>
public sealed record UserId(Guid Id)
{
    /// <summary>
    /// Initializes a new instance of the <see cref="UserId" /> record.
    /// </summary>
    /// <returns>A new UserId object.</returns>
    public static UserId New() => new(Guid.NewGuid());

    public override string ToString() => Id.ToString();
}

C++ have structs but not immutability so here the id field is marked as private with a method named value() to get the value.

struct UserId {
    UserId(const string _id)
    {
        id = _id;
    }

    string value() const
    {
        return id;
    }

    bool operator==(const UserId& rhs) const
    {
        return value() == rhs.value();
    }

private:
    string id;
};

ostream& operator << (ostream &os, const UserId &id)
{
    return os << id.value() << std::endl;
}

Crystal's standard library provides the record macro for creating records which are immutable structs and lets you create override the built-in to_s method.^[4]

require "uuid"

# Represents a user identifier.
record UserId, id : String do
  def initialize()
    @id = UUID.v4.to_s
  end

  def to_s(io)
    io << id
  end

  def self.empty
    self.new(UUID.empty.to_s)
  end
end

D have immutable structs.^[5]

import std;

/** Represents a user identifier. */
immutable struct UserId
{
    immutable UUID id;

    /** Initializes a new instance of the UserId struct. */
    this(immutable string id)
    {
        this.id = UUID(id);
    }

    public static UserId create()
    {
        return UserId(randomUUID.toString());
    }

    string toString()
    {
        return this.id.toString();
    }
}

Dart have classes with operator overloading.

import 'package:meta/meta.dart';

/// Represents a user identifier.
@immutable
final class UserId {
  final String id;

  /// Initializes a new instance of the UserId struct.
  const UserId(this.id);

  @override
  operator ==(other) => other is UserId && other.id == id;
  @override
  int get hashCode => id.hashCode;
  @override
  String toString() => id;
}

F# lets you create override the Equals, GetHashCode and ToString methods.

open System

/// <summary>
/// Represents a user identifier.
/// </summary>
/// <param name="id">The user identifier.</param>
type UserId(id: Guid) =
    member x.id = id
    static member New() = Guid.NewGuid()
    static member Empty = Guid.Empty
    override x.Equals(b) =
      match b with
      | :? UserId as p -> id = p.id
      | _ -> false
    override x.GetHashCode() = hash id
    override x.ToString() = id.ToString()

Go have structs which provide equality testing. Go however does not provide immutability.

// Represents a user identifier.
type UserId struct{ id string }

// Creates a new user identifier.
func NewUserId(id string) UserId { return UserId{id: id} }

func (x UserId) String() string { return x.id }

Groovy have record classes which provide immutability and equality testing.^[6]

/**
 * Represents a user identifier.
 *
 * @param id The user identifier.
 */
record UserId(String id) {
    String toString() { id }
}

Haskell can create user-defined custom data types using the newtype keyword.^[7] It provides equality testing using the Eq standard class and printing using the Read and Show standard classes.

-- Represents a user identifier.
newtype UserId = UserId String deriving (Eq, Read, Show)

Java have records which provide equality testing.^[8] The record is declared using the final modifier keyword to prevent inheritance. It overrides the built-in toString() method.

import java.util.UUID;

/**
 * Represents a user identifier.
 * @param id The user identifier.
 */
public final record UserId(UUID id) {
    /**
     * Initializes a new instance of the UserId record.
     * @return A new UserId object.
     */
    public static UserId newId() {
        return new UserId(UUID.randomUUID());
    }

    public String toString() {
        return id.toString();
    }
}

This JavaScript example implementation provides the toJSON method used by the JSON.stringify()^[9] function to serialize the class into a simple string instead of a composite data type. It calls Object.freeze() to make the instance immutable.^[10] It overrides the built-in toString() method^[11] and the valueOf() method.^[12]

class UserId {
  #id;

  constructor(id) {
    if (id == undefined) {
      throw new TypeError("Argument is null or undefined.");
    }
    this.#id = id;
    Object.freeze(this);
  }

  static empty = new this.prototype.constructor("00000000-0000-0000-0000-000000000000");

  static new() {
    return new this.prototype.constructor(crypto.randomUUID());
  }

  equals(id) {
    return id instanceof this.constructor && this.#id === id.valueOf();
  }

  toJSON() {
  	return this.#id;
  }

  toString() {
    return this.#id;
  }

  valueOf() {
  	return this.#id;
  }
}

Julia have immutable composite data types.^[13]

using UUIDs

"Represents a user identifier."
struct UserId
    id::UUID
end

Base.string(userId::UserId) = userId.id

Kotlin have "inline classes".^[14]

/**
 * Represents a user identifier.
 *
 * @property id The user identifier.
 * @constructor Creates a user identifier.
 */
@JvmInline
public value class UserId(public val id: String) {
    override fun toString() = id
}

Nim have "distinct types".^[15][16]

## Represents a user identifier.
type UserId* = distinct string

This PHP example implementation implements the __toString() magic method.^[17] Furthermore, it implements the JsonSerializable interface which is used by the built-in json_encode function to serialize the class into a simple string instead of a composite data type.^[18] The class is declared using the final modifier keyword to prevent inheritance.^[19] PHP has traits as a way to re-use code.^[20]

/**
 * Represents a user identifier.
 */
final class UserId implements JsonSerializable
{
    use StronglyTypedIdentifier;
}

/**
 * Provides methods for use with strongly typed identifiers.
 */
trait StronglyTypedIdentifier
{
    /**
     * Initializes a new instance of the UserId object.
     * @param string $id The user identifier.
     */
    public function __construct(public readonly string $id) {}

    /**
     * Creates a new user identifier.
     */
    public static function new(): self
    {
        return new self(bin2hex(random_bytes(16)));
    }

    public function jsonSerialize(): string
    {
        return $this->id;
    }

    public function __toString(): string
    {
        return $this->id;
    }
}

Python has data classes which provides equality testing and can be made immutable using the frozen parameter.^[21] It overrides the __str__ dunder method.^[22]

This example implementation includes a static method which can be used to initialize a new instance with a randomly generated universally unique identifier (UUID).

from dataclasses import dataclass
import uuid

@dataclass(frozen=True)
class UserId:
    """Represents a user identifier."""

    id: uuid.UUID

    @staticmethod
    def new() -> Self:
        """Create a new user identifier."""
        return __class__(uuid.uuid4())

    def __str__(self):
        return str(self.id)

Python also has NewType which can be used to create new data types.^[23]

from typing import NewType

UserId = NewType('UserId', int)

Ruby have data classes which provides equality testing and are immutable.^[24] It overrides the built-in to_s method.

This example implementation includes a static method which can be used to initialize a new instance with a randomly generated universally unique identifier (UUID).

require 'securerandom'

# Represents a user identifier.
UserId = Data.define(:id) do
  # Create a new user identifier.
  def self.create
    self.new(SecureRandom.uuid)
  end

  def self.empty
    self.new('00000000-0000-0000-0000-000000000000')
  end

  def to_s
    id
  end
end

In Rust this can be done using a tuple struct containing a single value.^[25] This example implementation implements the Debug^[26] and the PartialEq^[27] traits. The PartialEq trait provides equality testing.

// Represents a user identifier.
#[derive(Debug, PartialEq)]
pub struct UserId(String);

Scala have case classes which provide immutability and equality testing.^[28] The case class is sealed to prevent inheritance.

import java.util.UUID

/** Represents a user identifier.
  *
  * @constructor
  *   Create a new user identifier.
  * @param id
  *   The user identifier.
  */
sealed case class UserId(id: UUID)

object UserId:
  /** Initializes a new instance of the UserId class. */
  def create(): UserId = UserId(UUID.randomUUID())

Swift have the CustomStringConvertible protocol which can be used to provide its own representation to be used when converting an instance to a string,^[29] and the Equatable protocol which provides equality testing.^[30]

import Foundation

/// Represents a user identifier.
struct UserId: CustomStringConvertible, Equatable {
    private let id: UUID

    init(_ id: UUID) {
        self.id = id
    }

    var description: String {
        return id.uuidString.lowercased
    }

    /// Creates a new user identifier.
    static func new() -> Self {
        return Self(UUID())
    }
}

Zig have structs^[31] with constants but by design does not have operator overloading^[32] and method overriding.

/// Represents a user identifier.
const UserId = struct {
    value: i32,

    /// Initializes a new instance of the UserId struct.
    pub fn init(value: i32) UserId {
        return UserId{ .value = value };
    }
};

• Domain-driven design
• Type safety
• Value object

• https://wiki.c2.com/?PrimitiveObsession