Bridge Design Pattern

// ── The implementor side: how a message physically leaves the building ──
public interface Channel {
    void deliver(Recipient to, String subject, String body);
}

public final class SmsChannel implements Channel {
    public void deliver(Recipient to, String subject, String body) {
        sms.send(to.phone(), truncate(subject + ": " + body, 160));
    }
}

public final class EmailChannel implements Channel { /* … */ }

// ── The abstraction side: what the message MEANS ────────────────────────
public abstract class Notification {

    protected final Channel channel;      // ← the bridge, one reference

    protected Notification(Channel channel) {
        this.channel = channel;
    }

    public abstract void send(Recipient to);
}

public final class OtpNotification extends Notification {

    private final String code;

    public OtpNotification(Channel channel, String code) {
        super(channel);
        this.code = code;
    }

    @Override public void send(Recipient to) {
        // Policy lives here: expiry wording, no-reply, never log the code.
        channel.deliver(to, "Your verification code",
                        code + " — expires in 10 minutes. Do not share it.");
    }
}

// Composed at the wiring site, and every combination is now legal for free:
Notification otp = new OtpNotification(new SmsChannel(), "481920");

// Adding WhatsAppChannel is ONE new class. No notification changes.

from typing import Protocol


class Channel(Protocol):
    def deliver(self, to: Recipient, subject: str, body: str) -> None: ...


class SmsChannel:
    def deliver(self, to: Recipient, subject: str, body: str) -> None:
        sms.send(to.phone, f"{subject}: {body}"[:160])


class Notification:
    def __init__(self, channel: Channel) -> None:
        self._channel = channel          # the bridge

    def send(self, to: Recipient) -> None:
        raise NotImplementedError


class OtpNotification(Notification):
    def __init__(self, channel: Channel, code: str) -> None:
        super().__init__(channel)
        self._code = code

    def send(self, to: Recipient) -> None:
        self._channel.deliver(
            to,
            "Your verification code",
            f"{self._code} — expires in 10 minutes. Do not share it.",
        )


otp = OtpNotification(SmsChannel(), "481920")

# Python's honest alternative: with no compile-time coupling to fear, many
# codebases skip the Notification base class entirely and pass the channel to a
# plain function — `send_otp(channel, to, code)`. That IS the bridge; the
# hierarchy is optional scaffolding. Keep the class when the abstraction side
# has real state or several related operations, drop it when it doesn't.

#include <memory>
#include <string>

class Channel {                              // implementor
public:
    virtual ~Channel() = default;
    virtual void deliver(const Recipient&, std::string subject, std::string body) = 0;
};

class SmsChannel final : public Channel {
public:
    void deliver(const Recipient& to, std::string subject, std::string body) override;
};

class Notification {                         // abstraction
public:
    explicit Notification(std::shared_ptr<Channel> channel)
        : channel_(std::move(channel)) {}
    virtual ~Notification() = default;

    virtual void send(const Recipient&) = 0;

protected:
    std::shared_ptr<Channel> channel_;       // the bridge
};

class OtpNotification final : public Notification {
public:
    OtpNotification(std::shared_ptr<Channel> channel, std::string code)
        : Notification(std::move(channel)), code_(std::move(code)) {}

    void send(const Recipient& to) override {
        channel_->deliver(to, "Your verification code",
                          code_ + " — expires in 10 minutes.");
    }

private:
    std::string code_;
};

// GoF's other name for this pattern is HANDLE/BODY, and C++ programmers already
// use a degenerate version of it every day: the pimpl idiom is a Bridge with
// exactly one implementor, adopted for compile-time isolation rather than for
// combinatorial growth. Same structure, different reason.

public interface IChannel
{
    Task DeliverAsync(Recipient to, string subject, string body, CancellationToken ct = default);
}

public sealed class SmsChannel(ISmsClient sms) : IChannel
{
    public Task DeliverAsync(Recipient to, string subject, string body, CancellationToken ct = default)
        => sms.SendAsync(to.Phone, $"{subject}: {body}"[..Math.Min(160, subject.Length + body.Length + 2)], ct);
}

public abstract class Notification(IChannel channel)
{
    protected IChannel Channel { get; } = channel;   // the bridge

    public abstract Task SendAsync(Recipient to, CancellationToken ct = default);
}

public sealed class OtpNotification(IChannel channel, string code) : Notification(channel)
{
    public override Task SendAsync(Recipient to, CancellationToken ct = default)
        => Channel.DeliverAsync(to, "Your verification code",
                                $"{code} — expires in 10 minutes. Do not share it.", ct);
}

// Keyed services (.NET 8+) let the container pick the implementor side at
// runtime without a factory of your own:
//
//     services.AddKeyedScoped<IChannel, SmsChannel>("sms");
//     services.AddKeyedScoped<IChannel, EmailChannel>("email");
//
//     var channel = provider.GetRequiredKeyedService<IChannel>(user.PreferredChannel);
//
// That is the bridge assembled by configuration, which is where it belongs.

// Two independent families, joined by one reference. No classes required —
// closures express the bridge just as well.

const smsChannel = {
  deliver: (to, subject, body) => sms.send(to.phone, `${subject}: ${body}`.slice(0, 160)),
}

const emailChannel = {
  deliver: (to, subject, body) => smtp.send({ to: to.email, subject, html: body }),
}

const otpNotification = (channel, code) => ({
  send: to =>
    channel.deliver(
      to,
      'Your verification code',
      `${code} — expires in 10 minutes. Do not share it.`,
    ),
})

const otp = otpNotification(smsChannel, '481920')
await otp.send(recipient)

// React is the largest Bridge most JavaScript developers use daily: your
// components are the abstraction, and the RENDERER is the implementor —
// react-dom, react-native and react-three-fiber are concrete implementors of
// the same reconciler interface. That is why one component tree can be drawn to
// a browser, a phone or a canvas without changing the components.

package notify

// Go has no inheritance, so the "two hierarchies" become two interfaces and a
// struct that embeds one — which arguably makes the pattern clearer here than
// in the languages it was written for.

type Channel interface {                     // implementor
	Deliver(ctx context.Context, to Recipient, subject, body string) error
}

type SMS struct{ client *sms.Client }

func (s SMS) Deliver(ctx context.Context, to Recipient, subject, body string) error {
	return s.client.Send(ctx, to.Phone, truncate(subject+": "+body, 160))
}

type OTP struct {
	Channel        // ← embedded: the bridge, and OTP now satisfies Channel too
	Code    string
}

func (o OTP) Send(ctx context.Context, to Recipient) error {
	return o.Deliver(ctx, to, "Your verification code",
		o.Code+" — expires in 10 minutes. Do not share it.")
}

// otp := OTP{Channel: SMS{client}, Code: "481920"}
//
// database/sql is the standard library's bridge and worth studying: sql.DB is
// the abstraction every Go program calls, driver.Driver is the implementor, and
// Postgres, MySQL and SQLite drivers are written by people who have never seen
// your query code.

interface Channel {
  deliver(to: Recipient, subject: string, body: string): Promise<void>
}

class SmsChannel implements Channel {
  async deliver(to: Recipient, subject: string, body: string): Promise<void> {
    await sms.send(to.phone, `${subject}: ${body}`.slice(0, 160))
  }
}

abstract class Notification {
  constructor(protected readonly channel: Channel) {}    // the bridge
  abstract send(to: Recipient): Promise<void>
}

class OtpNotification extends Notification {
  constructor(channel: Channel, private readonly code: string) {
    super(channel)
  }

  async send(to: Recipient): Promise<void> {
    await this.channel.deliver(
      to,
      'Your verification code',
      `${this.code} — expires in 10 minutes. Do not share it.`,
    )
  }
}

// The type system can prove the combinatorial claim for you. This type is every
// legal pairing, and it stays a two-line definition however many of each you add:
type Send = (channel: Channel, notification: NotificationKind) => Promise<void>

// Whereas the class-per-combination design would need a union of N × M names,
// which is exactly the explosion the pattern exists to prevent.