Adapter: make incompatible interfaces fit

Python 3.14 · main.py

from abc import ABC, abstractmethod


class NotifierError(Exception):
    pass


class Notifier(ABC):
    @abstractmethod
    def send(self, phone: str, text: str) -> str: ...


class SmsGatewayClient:
    """The SDK, which cannot change: a dictionary in, a status code out."""

    def __init__(self) -> None:
        self.accepted = 0

    def dispatch(self, payload: dict[str, str]) -> tuple[int, str]:
        msisdn = payload["msisdn"]
        print(f"  SDK got {msisdn}")
        if not (msisdn.isdigit() and len(msisdn) == 12):
            return 4011, ""
        self.accepted += 1
        return 0, f"GW-{self.accepted:06d}"  # code 0: accepted


class SmsNotifier(Notifier):
    """The adapter: a Notifier outside, calls to the SDK inside."""

    def __init__(self, client: SmsGatewayClient, sender: str) -> None:
        self._client = client
        self._sender = sender

    def send(self, phone: str, text: str) -> str:
        digits = "".join(ch for ch in phone if ch.isdigit())
        payload = {"msisdn": digits, "body": text, "sender": self._sender}
        code, message_id = self._client.dispatch(payload)
        if code != 0:
            reason = "invalid number" if code == 4011 else f"code {code}"
            raise NotifierError(f"cannot send to {phone}: {reason}")
        return message_id


def remind(notifier: Notifier, phone: str, time: str) -> None:
    try:
        receipt = notifier.send(phone, f"Visit at {time}.")
        print(f"sent to {phone}: {receipt}")
    except NotifierError as error:
        print(f"failed: {error}")


notifier = SmsNotifier(SmsGatewayClient(), sender="CLINIC")
remind(notifier, "+91 98765 43210", "10:30")
remind(notifier, "+91 98765", "11:00")

In Python: Notifier is an abstract base class, so a subclass that leaves out send() cannot be created. The SDK answers with a tuple, the status code and the id, which send() unpacks.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

class NotifierError extends Error {}

/** @typedef {{ send(phone: string, text: string): string }} Notifier */

/** The SDK, which cannot change: a dictionary in, a status code out. */
class SmsGatewayClient {
  accepted = 0;

  dispatch(payload) {
    const { msisdn } = payload;
    console.log(`  SDK got ${msisdn}`);
    if (!/^\d{12}$/.test(msisdn)) return [4011, ""];
    this.accepted += 1;
    return [0, `GW-${String(this.accepted).padStart(6, "0")}`]; // code 0: accepted
  }
}

/** The adapter: a Notifier outside, calls to the SDK inside. */
class SmsNotifier {
  #client;
  #sender;

  constructor(client, sender) {
    this.#client = client;
    this.#sender = sender;
  }

  send(phone, text) {
    const digits = phone.replace(/\D/g, "");
    const [code, messageId] = this.#client.dispatch({
      msisdn: digits,
      body: text,
      sender: this.#sender,
    });
    if (code !== 0) {
      const reason = code === 4011 ? "invalid number" : `code ${code}`;
      throw new NotifierError(`cannot send to ${phone}: ${reason}`);
    }
    return messageId;
  }
}

/** @param {Notifier} notifier @param {string} phone @param {string} time */
function remind(notifier, phone, time) {
  try {
    const receipt = notifier.send(phone, `Visit at ${time}.`);
    console.log(`sent to ${phone}: ${receipt}`);
  } catch (error) {
    if (!(error instanceof NotifierError)) throw error;
    console.log(`failed: ${error.message}`);
  }
}

const notifier = new SmsNotifier(new SmsGatewayClient(), "CLINIC");
remind(notifier, "+91 98765 43210", "10:30");
remind(notifier, "+91 98765", "11:00");

In JavaScript: JavaScript has no interfaces, so Notifier is a JSDoc type that editors check.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.Locale;
import java.util.Map;

public class Main {
  static class NotifierException extends Exception {
    NotifierException(String message) {
      super(message);
    }
  }

  interface Notifier {
    String send(String phone, String text) throws NotifierException;
  }

  record Reply(int code, String messageId) {} // code 0: accepted

  /** The SDK, which cannot change: a dictionary in, a status code out. */
  static class SmsGatewayClient {
    private int accepted = 0;

    Reply dispatch(Map<String, String> payload) {
      String msisdn = payload.get("msisdn");
      System.out.println("  SDK got " + msisdn);
      if (msisdn.length() != 12 || !msisdn.chars().allMatch(Character::isDigit)) {
        return new Reply(4011, "");
      }
      accepted++;
      return new Reply(0, String.format("GW-%06d", accepted));
    }
  }

  /** The adapter: a Notifier outside, calls to the SDK inside. */
  static class SmsNotifier implements Notifier {
    private final SmsGatewayClient client;
    private final String sender;

    SmsNotifier(SmsGatewayClient client, String sender) {
      this.client = client;
      this.sender = sender;
    }

    @Override
    public String send(String phone, String text) throws NotifierException {
      var digits = new StringBuilder();
      phone.chars().filter(Character::isDigit).forEach(digits::appendCodePoint);
      var reply =
          client.dispatch(Map.of("msisdn", digits.toString(), "body", text, "sender", sender));
      if (reply.code() != 0) {
        var reason = reply.code() == 4011 ? "invalid number" : "code " + reply.code();
        throw new NotifierException("cannot send to " + phone + ": " + reason);
      }
      return reply.messageId();
    }
  }

  static void remind(Notifier notifier, String phone, String time) {
    try {
      var receipt = notifier.send(phone, "Visit at " + time + ".");
      System.out.println("sent to " + phone + ": " + receipt);
    } catch (NotifierException error) {
      System.out.println("failed: " + error.getMessage());
    }
  }

  public static void main(String[] args) {
    Locale.setDefault(Locale.ROOT);
    var notifier = new SmsNotifier(new SmsGatewayClient(), "CLINIC");
    remind(notifier, "+91 98765 43210", "10:30");
    remind(notifier, "+91 98765", "11:00");
  }
}

In Java: The SDK's failure becomes a checked NotifierException, so the compiler makes remind() catch it or declare it. Java names its exception classes with Exception rather than Error.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <algorithm>
#include <format>
#include <map>
#include <print>
#include <stdexcept>
#include <string>

struct NotifierError : std::runtime_error {
  using std::runtime_error::runtime_error;
};

struct Notifier {
  virtual ~Notifier() = default;
  virtual std::string send(std::string_view phone, std::string_view text) = 0;
};

using Payload = std::map<std::string, std::string>;

bool is_digit(char ch) { return ch >= '0' && ch <= '9'; }

// The SDK, which cannot change: a dictionary in, a status code out.
struct SmsGatewayClient {
  int accepted = 0;

  int dispatch(const Payload &payload, std::string &message_id) {
    const std::string &msisdn = payload.at("msisdn");
    std::println("  SDK got {}", msisdn);
    if (msisdn.size() != 12 || !std::ranges::all_of(msisdn, is_digit)) {
      return 4011;
    }
    message_id = std::format("GW-{:06}", ++accepted);
    return 0;
  }
};

// The adapter: a Notifier outside, calls to the SDK inside.
class SmsNotifier : public Notifier {
public:
  SmsNotifier(SmsGatewayClient &client, std::string sender)
      : client_(client), sender_(std::move(sender)) {}

  std::string send(std::string_view phone, std::string_view text) override {
    std::string digits;
    std::ranges::copy_if(phone, std::back_inserter(digits), is_digit);
    Payload payload{
        {"msisdn", digits}, {"body", std::string(text)}, {"sender", sender_}};
    std::string message_id;
    int code = client_.dispatch(payload, message_id);
    if (code != 0) {
      auto reason = code == 4011 ? std::string("invalid number")
                                 : std::format("code {}", code);
      throw NotifierError(std::format("cannot send to {}: {}", phone, reason));
    }
    return message_id;
  }

private:
  SmsGatewayClient &client_;
  std::string sender_;
};

void remind(Notifier &notifier, std::string_view phone, std::string_view time) {
  try {
    auto receipt = notifier.send(phone, std::format("Visit at {}.", time));
    std::println("sent to {}: {}", phone, receipt);
  } catch (const NotifierError &error) {
    std::println("failed: {}", error.what());
  }
}

int main() {
  SmsGatewayClient client;
  SmsNotifier notifier(client, "CLINIC");
  remind(notifier, "+91 98765 43210", "10:30");
  remind(notifier, "+91 98765", "11:00");
}

In C++: The adapter keeps a reference to the SDK it was given, so the SDK must outlive the adapter. Here the SDK writes the id through a reference and returns the code, in the style of a C library.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

var notifier = new SmsNotifier(new SmsGatewayClient(), "CLINIC");
Remind(notifier, "+91 98765 43210", "10:30");
Remind(notifier, "+91 98765", "11:00");

static void Remind(INotifier notifier, string phone, string time)
{
    try
    {
        var receipt = notifier.Send(phone, $"Visit at {time}.");
        Console.WriteLine($"sent to {phone}: {receipt}");
    }
    catch (NotifierException error)
    {
        Console.WriteLine($"failed: {error.Message}");
    }
}

sealed class NotifierException(string message) : Exception(message);

interface INotifier
{
    string Send(string phone, string text);
}

/// <summary>The SDK, which cannot change: a dictionary in, a status code out.</summary>
sealed class SmsGatewayClient
{
    int accepted;

    public (int Code, string MessageId) Dispatch(Dictionary<string, string> payload)
    {
        var msisdn = payload["msisdn"];
        Console.WriteLine($"  SDK got {msisdn}");
        if (msisdn.Length != 12 || !msisdn.All(char.IsAsciiDigit))
        {
            return (4011, "");
        }
        accepted++;
        return (0, $"GW-{accepted:D6}"); // code 0: accepted
    }
}

/// <summary>The adapter: a Notifier outside, calls to the SDK inside.</summary>
sealed class SmsNotifier(SmsGatewayClient client, string sender) : INotifier
{
    public string Send(string phone, string text)
    {
        var digits = string.Concat(phone.Where(char.IsAsciiDigit));
        var (code, messageId) = client.Dispatch(
            new() { ["msisdn"] = digits, ["body"] = text, ["sender"] = sender });
        if (code != 0)
        {
            var reason = code == 4011 ? "invalid number" : $"code {code}";
            throw new NotifierException($"cannot send to {phone}: {reason}");
        }
        return messageId;
    }
}

In C#: Interface names start with I, as .NET's naming guidelines ask. The SDK returns a named tuple, (int Code, string MessageId), which the adapter deconstructs.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

C is left out of this example: C has no interfaces or exceptions, so the target would be a struct of function pointers that reports failures through out parameters, another design.

PHP 8.5 · main.php

<?php

declare(strict_types=1);

final class NotifierException extends Exception {}

interface Notifier
{
    public function send(string $phone, string $text): string;
}

/** The SDK, which cannot change: a dictionary in, a status code out. */
final class SmsGatewayClient
{
    private int $accepted = 0;

    /**
     * @param array{msisdn: string, body: string, sender: string} $payload
     * @return array{int, string} the code, 0 when accepted, and the message's id
     */
    public function dispatch(array $payload): array
    {
        $msisdn = $payload['msisdn'];
        echo "  SDK got {$msisdn}\n";
        if (preg_match('/^\d{12}$/', $msisdn) !== 1) {
            return [4011, ''];
        }
        $this->accepted++;
        return [0, sprintf('GW-%06d', $this->accepted)];
    }
}

/** The adapter: a Notifier outside, calls to the SDK inside. */
final class SmsNotifier implements Notifier
{
    public function __construct(private SmsGatewayClient $client, private string $sender) {}

    public function send(string $phone, string $text): string
    {
        $digits = preg_replace('/\D/', '', $phone);
        $payload = ['msisdn' => $digits, 'body' => $text, 'sender' => $this->sender];
        [$code, $messageId] = $this->client->dispatch($payload);
        if ($code !== 0) {
            $reason = $code === 4011 ? 'invalid number' : "code {$code}";
            throw new NotifierException("cannot send to {$phone}: {$reason}");
        }
        return $messageId;
    }
}

function remind(Notifier $notifier, string $phone, string $time): void
{
    try {
        $receipt = $notifier->send($phone, "Visit at {$time}.");
        echo "sent to {$phone}: {$receipt}\n";
    } catch (NotifierException $error) {
        echo "failed: {$error->getMessage()}\n";
    }
}

$notifier = new SmsNotifier(new SmsGatewayClient(), 'CLINIC');
remind($notifier, '+91 98765 43210', '10:30');
remind($notifier, '+91 98765', '11:00');

In PHP: Constructor promotion, private SmsGatewayClient $client, declares and sets the adapter's fields in one line. The payload's keys are written down as a PHPDoc array shape.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

use std::collections::HashMap;
use std::fmt;

#[derive(Debug)]
struct NotifierError(String);

impl fmt::Display for NotifierError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.0)
    }
}

trait Notifier {
    fn send(&mut self, phone: &str, text: &str) -> Result<String, NotifierError>;
}

/// The SDK, which cannot change: a dictionary in, a status code out.
#[derive(Default)]
struct SmsGatewayClient {
    accepted: u32,
}

impl SmsGatewayClient {
    /// Ok with the message's id when it was accepted, or Err with a status code.
    fn dispatch(&mut self, payload: &HashMap<&str, String>) -> Result<String, u32> {
        let msisdn = &payload["msisdn"];
        println!("  SDK got {msisdn}");
        if msisdn.len() != 12 || !msisdn.chars().all(|ch| ch.is_ascii_digit()) {
            return Err(4011);
        }
        self.accepted += 1;
        Ok(format!("GW-{:06}", self.accepted))
    }
}

/// The adapter: a Notifier outside, calls to the SDK inside.
struct SmsNotifier {
    client: SmsGatewayClient,
    sender: String,
}

impl Notifier for SmsNotifier {
    fn send(&mut self, phone: &str, text: &str) -> Result<String, NotifierError> {
        let digits: String = phone.chars().filter(char::is_ascii_digit).collect();
        let payload = HashMap::from([
            ("msisdn", digits),
            ("body", text.to_string()),
            ("sender", self.sender.clone()),
        ]);
        let reason = match self.client.dispatch(&payload) {
            Ok(message_id) => return Ok(message_id),
            Err(4011) => "invalid number".to_string(),
            Err(code) => format!("code {code}"),
        };
        Err(NotifierError(format!("cannot send to {phone}: {reason}")))
    }
}

fn remind(notifier: &mut impl Notifier, phone: &str, time: &str) {
    match notifier.send(phone, &format!("Visit at {time}.")) {
        Ok(receipt) => println!("sent to {phone}: {receipt}"),
        Err(error) => println!("failed: {error}"),
    }
}

fn main() {
    let client = SmsGatewayClient::default();
    let mut notifier = SmsNotifier {
        client,
        sender: "CLINIC".to_string(),
    };
    remind(&mut notifier, "+91 98765 43210", "10:30");
    remind(&mut notifier, "+91 98765", "11:00");
}

In Rust: The SDK answers with Result<String, u32>, the Rust way to say "an id or a status code", and a match turns Err(4011) into the application's NotifierError.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

class NotifierError extends Error {}

interface Notifier {
  send(phone: string, text: string): string;
}

type Payload = Record<"msisdn" | "body" | "sender", string>;

/** The SDK, which cannot change: a dictionary in, a status code out. */
class SmsGatewayClient {
  #accepted = 0;

  dispatch(payload: Payload): [code: number, messageId: string] {
    const { msisdn } = payload;
    console.log(`  SDK got ${msisdn}`);
    if (!/^\d{12}$/.test(msisdn)) return [4011, ""];
    this.#accepted += 1;
    return [0, `GW-${String(this.#accepted).padStart(6, "0")}`]; // code 0: accepted
  }
}

/** The adapter: a Notifier outside, calls to the SDK inside. */
class SmsNotifier implements Notifier {
  readonly #client: SmsGatewayClient;
  readonly #sender: string;

  constructor(client: SmsGatewayClient, sender: string) {
    this.#client = client;
    this.#sender = sender;
  }

  send(phone: string, text: string): string {
    const digits = phone.replace(/\D/g, "");
    const [code, messageId] = this.#client.dispatch({
      msisdn: digits,
      body: text,
      sender: this.#sender,
    });
    if (code !== 0) {
      const reason = code === 4011 ? "invalid number" : `code ${code}`;
      throw new NotifierError(`cannot send to ${phone}: ${reason}`);
    }
    return messageId;
  }
}

function remind(notifier: Notifier, phone: string, time: string): void {
  try {
    const receipt = notifier.send(phone, `Visit at ${time}.`);
    console.log(`sent to ${phone}: ${receipt}`);
  } catch (error) {
    if (!(error instanceof NotifierError)) throw error;
    console.log(`failed: ${error.message}`);
  }
}

const notifier = new SmsNotifier(new SmsGatewayClient(), "CLINIC");
remind(notifier, "+91 98765 43210", "10:30");
remind(notifier, "+91 98765", "11:00");

In TypeScript: The compiler checks the adapter against Notifier where it says implements, and nothing of the interface is left when the program runs.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strings"
	"unicode"
)

// NotifierError says, in the application's words, why a message could not be sent.
type NotifierError struct{ Phone, Reason string }

func (e *NotifierError) Error() string { return "cannot send to " + e.Phone + ": " + e.Reason }

// Notifier is the interface the application owns.
type Notifier interface {
	Send(phone, text string) (string, error)
}

// SmsGatewayClient is the SDK, which cannot be changed: a dictionary in, a status code out.
type SmsGatewayClient struct{ accepted int }

// Dispatch returns the status code, 0 when the message was accepted, and the message's id.
func (c *SmsGatewayClient) Dispatch(payload map[string]string) (code int, messageID string) {
	msisdn := payload["msisdn"]
	fmt.Println("  SDK got", msisdn)
	if len(msisdn) != 12 || strings.Trim(msisdn, "0123456789") != "" {
		return 4011, ""
	}
	c.accepted++
	return 0, fmt.Sprintf("GW-%06d", c.accepted)
}

// SmsNotifier is the adapter: a Notifier outside, calls to the SDK inside.
type SmsNotifier struct {
	client *SmsGatewayClient
	sender string
}

func (n SmsNotifier) Send(phone, text string) (string, error) {
	digits := strings.Map(func(r rune) rune {
		if unicode.IsDigit(r) {
			return r
		}
		return -1
	}, phone)
	payload := map[string]string{"msisdn": digits, "body": text, "sender": n.sender}
	code, messageID := n.client.Dispatch(payload)
	switch code {
	case 0:
		return messageID, nil
	case 4011:
		return "", &NotifierError{Phone: phone, Reason: "invalid number"}
	default:
		return "", &NotifierError{Phone: phone, Reason: fmt.Sprintf("code %d", code)}
	}
}

func remind(notifier Notifier, phone, time string) {
	receipt, err := notifier.Send(phone, "Visit at "+time+".")
	if err != nil {
		fmt.Println("failed:", err)
		return
	}
	fmt.Printf("sent to %s: %s\n", phone, receipt)
}

func main() {
	notifier := SmsNotifier{client: &SmsGatewayClient{}, sender: "CLINIC"}
	remind(notifier, "+91 98765 43210", "10:30")
	remind(notifier, "+91 98765", "11:00")
}

In Go: Dispatch returns two values, the code and the id, and Send returns the id and an error value. NotifierError is a type of its own, so a caller can look for it with errors.As.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

struct NotifierError: Error, CustomStringConvertible {
  let description: String
}

protocol Notifier {
  func send(to phone: String, text: String) throws(NotifierError) -> String
}

/// The SDK, which cannot change: a dictionary in, a status code out.
final class SmsGatewayClient {
  private var accepted = 0

  func dispatch(_ payload: [String: String]) -> (code: Int, messageID: String) {
    let msisdn = payload["msisdn", default: ""]
    print("  SDK got \(msisdn)")
    guard msisdn.count == 12, msisdn.allSatisfy(\.isASCIIDigit) else { return (4011, "") }
    accepted += 1
    let number = String(accepted)
    return (0, "GW-" + String(repeating: "0", count: 6 - number.count) + number)  // 0: accepted
  }
}

extension Character {
  var isASCIIDigit: Bool { isASCII && isNumber }
}

/// The adapter: a Notifier outside, calls to the SDK inside.
struct SmsNotifier: Notifier {
  let client: SmsGatewayClient
  let sender: String

  func send(to phone: String, text: String) throws(NotifierError) -> String {
    let digits = String(phone.filter(\.isASCIIDigit))
    let reply = client.dispatch(["msisdn": digits, "body": text, "sender": sender])
    guard reply.code == 0 else {
      let reason = reply.code == 4011 ? "invalid number" : "code \(reply.code)"
      throw NotifierError(description: "cannot send to \(phone): \(reason)")
    }
    return reply.messageID
  }
}

func remind(_ notifier: any Notifier, phone: String, at time: String) {
  do {
    let receipt = try notifier.send(to: phone, text: "Visit at \(time).")
    print("sent to \(phone): \(receipt)")
  } catch {
    print("failed: \(error)")
  }
}

let notifier = SmsNotifier(client: SmsGatewayClient(), sender: "CLINIC")
remind(notifier, phone: "+91 98765 43210", at: "10:30")
remind(notifier, phone: "+91 98765", at: "11:00")

In Swift: send(to:text:) is declared throws(NotifierError), so every caller knows the one error it can throw. Without Foundation the zeros of the message's id are padded by hand.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

# Raised when a message could not be sent.
class NotifierError < StandardError; end

# The SDK, which cannot change: a dictionary in, a status code out.
class SmsGatewayClient
  def initialize
    @accepted = 0
  end

  def dispatch(payload)
    msisdn = payload[:msisdn]
    puts "  SDK got #{msisdn}"
    return [4011, ''] unless msisdn.match?(/\A\d{12}\z/)

    @accepted += 1
    [0, format('GW-%06d', @accepted)] # code 0: accepted
  end
end

# The adapter: a Notifier outside, calls to the SDK inside. Ruby has no interface
# declarations: a Notifier is anything with deliver(phone, text).
class SmsNotifier
  def initialize(client, sender)
    @client = client
    @sender = sender
  end

  def deliver(phone, text)
    payload = { msisdn: phone.delete('^0-9'), body: text, sender: @sender }
    code, message_id = @client.dispatch(payload)
    return message_id if code.zero?

    reason = code == 4011 ? 'invalid number' : "code #{code}"
    raise NotifierError, "cannot send to #{phone}: #{reason}"
  end
end

def remind(notifier, phone, time)
  receipt = notifier.deliver(phone, "Visit at #{time}.")
  puts "sent to #{phone}: #{receipt}"
rescue NotifierError => e
  puts "failed: #{e.message}"
end

notifier = SmsNotifier.new(SmsGatewayClient.new, 'CLINIC')
remind(notifier, '+91 98765 43210', '10:30')
remind(notifier, '+91 98765', '11:00')

In Ruby: Every Ruby object already has a send method, which calls another method by its name, so the interface's method is called deliver here. phone.delete('^0-9') keeps only the digits.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

class NotifierException(
    message: String,
) : Exception(message)

interface Notifier {
    fun send(
        phone: String,
        text: String,
    ): String
}

/** The SDK, which cannot change: a dictionary in, a status code out. */
class SmsGatewayClient {
    private var accepted = 0

    fun dispatch(payload: Map<String, String>): Pair<Int, String> {
        val msisdn = payload.getValue("msisdn")
        println("  SDK got $msisdn")
        if (msisdn.length != 12 || !msisdn.all { it in '0'..'9' }) return 4011 to ""
        accepted++
        return 0 to "GW-" + accepted.toString().padStart(6, '0') // code 0: accepted
    }
}

/** The adapter: a Notifier outside, calls to the SDK inside. */
class SmsNotifier(
    private val client: SmsGatewayClient,
    private val sender: String,
) : Notifier {
    override fun send(
        phone: String,
        text: String,
    ): String {
        val digits = phone.filter { it in '0'..'9' }
        val payload = mapOf("msisdn" to digits, "body" to text, "sender" to sender)
        val (code, messageId) = client.dispatch(payload)
        if (code != 0) {
            val reason = if (code == 4011) "invalid number" else "code $code"
            throw NotifierException("cannot send to $phone: $reason")
        }
        return messageId
    }
}

fun remind(
    notifier: Notifier,
    phone: String,
    time: String,
) {
    try {
        val receipt = notifier.send(phone, "Visit at $time.")
        println("sent to $phone: $receipt")
    } catch (error: NotifierException) {
        println("failed: ${error.message}")
    }
}

fun main() {
    val notifier = SmsNotifier(SmsGatewayClient(), "CLINIC")
    remind(notifier, "+91 98765 43210", "10:30")
    remind(notifier, "+91 98765", "11:00")
}

In Kotlin: Kotlin has no checked exceptions, so nothing makes remind() catch NotifierException. The SDK returns a Pair, and val (code, messageId) takes it apart.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

final class NotifierException implements Exception {
  NotifierException(this.message);

  final String message;

  @override
  String toString() => message;
}

abstract interface class Notifier {
  String send(String phone, String text);
}

/// The SDK, which cannot change: a dictionary in, a status code out.
final class SmsGatewayClient {
  int _accepted = 0;

  (int, String) dispatch(Map<String, String> payload) {
    final msisdn = payload['msisdn']!;
    print('  SDK got $msisdn');
    if (!RegExp(r'^\d{12}$').hasMatch(msisdn)) return (4011, '');
    _accepted++;
    return (
      0,
      'GW-${_accepted.toString().padLeft(6, '0')}',
    ); // code 0: accepted
  }
}

/// The adapter: a Notifier outside, calls to the SDK inside.
final class SmsNotifier implements Notifier {
  SmsNotifier(this._client, this._sender);

  final SmsGatewayClient _client;
  final String _sender;

  @override
  String send(String phone, String text) {
    final digits = phone.replaceAll(RegExp(r'\D'), '');
    final payload = {'msisdn': digits, 'body': text, 'sender': _sender};
    final (code, messageId) = _client.dispatch(payload);
    if (code != 0) {
      final reason = code == 4011 ? 'invalid number' : 'code $code';
      throw NotifierException('cannot send to $phone: $reason');
    }
    return messageId;
  }
}

void remind(Notifier notifier, String phone, String time) {
  try {
    final receipt = notifier.send(phone, 'Visit at $time.');
    print('sent to $phone: $receipt');
  } on NotifierException catch (error) {
    print('failed: $error');
  }
}

void main() {
  final notifier = SmsNotifier(SmsGatewayClient(), 'CLINIC');
  remind(notifier, '+91 98765 43210', '10:30');
  remind(notifier, '+91 98765', '11:00');
}

In Dart: Notifier is an abstract interface class, which code in other libraries may implement but not extend. The SDK returns a record, (int, String), which a pattern takes apart.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart