Strongly typed identifier - Misplaced Pages

(Redirected from Strongly-typed identifier)

A strongly typed identifier is user-defined data type which serves as an identifier or key that is strongly typed. This is a solution to the "primitive obsession" code smell as mentioned by Martin Fowler. The data type should preferably be immutable if possible. It is common for implementations to handle equality testing, serialization and model binding.

The strongly typed identifier commonly wraps the data type used as the primary key in the database, such as a string, an integer or universally unique identifier (UUID).

Web frameworks can often be configured to model bind properties on view models that are strongly typed identifiers. Object–relational mappers can often be configured with value converters to map data between the properties on a model using strongly typed identifier data types and database columns.

Examples

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

C#

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

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++

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

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.

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

D have immutable structs.

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

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#

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

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

Groovy have record classes which provide immutability and equality testing.

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

Haskell

Haskell can create user-defined custom data types using the newtype keyword. 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

Java have records which provide equality testing. 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();
    }
}

JavaScript

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

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

Julia have immutable composite data types.

using UUIDs
"Represents a user identifier."
struct UserId
    id::UUID
end
Base.string(userId::UserId) = userId.id

Kotlin

Kotlin have "inline classes".

/**
 * 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

Nim have "distinct types".

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

PHP

This PHP example implementation implements the __toString() magic method. 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. The class is declared using the final modifier keyword to prevent inheritance. PHP has traits as a way to re-use code.

/**
 * 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

Python has data classes which provides equality testing and can be made immutable using the frozen parameter. It overrides the __str__ dunder 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).

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.

from typing import NewType
UserId = NewType('UserId', int)

Ruby

Ruby have data classes which provides equality testing and are immutable. 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

Rust

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

// Represents a user identifier.
#
pub struct UserId(String);

Scala

Scala have case classes which provide immutability and equality testing. 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

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

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

Zig have structs with constants but by design does not have operator overloading 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 };
    }
};

References

"Records - C# reference". learn.microsoft.com. Retrieved 23 January 2023.
"sealed modifier - C# Reference". learn.microsoft.com. Retrieved 23 January 2023.
"Object.ToString Method (System)". learn.microsoft.com. Retrieved 14 June 2023.
"Structs - Crystal". crystal-lang.org. Retrieved 21 February 2024.
"Structs, Unions - D Programming Language". dlang.org. Retrieved 30 May 2023.
"The Apache Groovy programming language - Object orientation". groovy-lang.org. Retrieved 24 December 2023.
"Newtype - HaskellWiki". wiki.haskell.org. Retrieved 18 June 2023.
"Record Classes". Oracle Help Center. Retrieved 24 January 2023.
"JSON.stringify() - JavaScript | MDN". developer.mozilla.org. Retrieved 23 January 2023.
"Object.freeze() - JavaScript | MDN". developer.mozilla.org. Retrieved 23 January 2023.
"Object.prototype.toString() - JavaScript | MDN". developer.mozilla.org. Retrieved 23 January 2023.
"Object.prototype.valueOf() - JavaScript | MDN". developer.mozilla.org. Retrieved 23 January 2023.
"Types · The Julia Language". docs.julialang.org. Retrieved 30 May 2023.
"Inline classes | Kotlin". Kotlin Help. Retrieved 23 January 2023.
"Nim Manual". nim-lang.org. Retrieved 4 August 2023.
"Nim by Example - Distinct Types". nim-by-example.github.io. Retrieved 4 August 2023.
"PHP: Magic Methods - Manual". www.php.net. Retrieved 23 January 2023.
"PHP: JsonSerializable::jsonSerialize - Manual". www.php.net. Retrieved 23 January 2023.
"PHP: Final Keyword - Manual". www.php.net. Retrieved 23 January 2023.
"PHP: Traits - Manual". www.php.net. Retrieved 2 May 2023.
"dataclasses — Data Classes". Python documentation. Python Software Foundation. Retrieved 23 January 2023.
"3. Data model". Python documentation. Python Software Foundation. Retrieved 12 June 2023.
"typing — Support for type hints". Python documentation. Python Software Foundation. Retrieved 17 June 2023.
"class Data - Documentation for Ruby 3.3". docs.ruby-lang.org. Retrieved 6 February 2023.
"New Type Idiom - Rust By Example". doc.rust-lang.org. Retrieved 18 June 2023.
"Debug in std::fmt - Rust". doc.rust-lang.org. Retrieved 23 January 2023.
"PartialEq in std::cmp - Rust". doc.rust-lang.org. Retrieved 23 January 2023.
"Case Classes". Scala Documentation. Retrieved 15 May 2023.
"CustomStringConvertible". Apple Developer Documentation. Retrieved 5 May 2023.
"Documentation". docs.swift.org. Retrieved 4 May 2023.
"Structs | zig.guide". zig.guide. 20 April 2024. Retrieved 15 October 2024.
"Documentation - The Zig Programming Language". Retrieved 15 October 2024.

External links

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

v t e Data types
Uninterpreted	Bit Byte Trit Tryte Word Bit array
Numeric	Arbitrary-precision or bignum Complex Decimal Fixed point Floating point Reduced precision Minifloat Half precision bfloat16 Single precision Double precision Quadruple precision Octuple precision Extended precision Long double Integer signedness Interval Rational
Pointer	Address physical virtual Reference
Text	Character String null-terminated
Composite	Algebraic data type generalized Array Associative array Class Dependent Equality Inductive Intersection List Object metaobject Option type Product Record or Struct Refinement Set Union tagged
Other	Boolean Bottom type Collection Enumerated type Exception Function type Opaque data type Recursive data type Semaphore Stream Strongly typed identifier Top type Type class Empty type Unit type Void
Related topics	Abstract data type Boxing Data structure Generic Kind metaclass Parametric polymorphism Primitive data type Interface Subtyping Type constructor Type conversion Type system Type theory Variable

Software design patterns

Gang of Four
patterns

Creational	Abstract factory Builder Factory method Prototype Singleton
Structural	Adapter Bridge Composite Decorator Facade Flyweight Proxy
Behavioral	Chain of responsibility Command Interpreter Iterator Mediator Memento Observer State Strategy Template method Visitor

Concurrency
patterns

Architectural
patterns

Other
patterns

Books

People

Communities