Interface Segregation Principle (ISP)

Python 3.14 · main.py

from typing import Protocol


class Barrier(Protocol):
    def open(self) -> str: ...

    def close(self) -> str: ...


class TagReader(Protocol):
    def read_tag(self) -> str | None: ...  # a resident's tag in range, or None


class TagGate(TagReader, Barrier, Protocol): ...  # two roles, composed


class VisitorDesk(Protocol):
    def print_pass(self, visitor: str, flat: str) -> str: ...


class Gate:
    def __init__(self, name: str, is_open: bool) -> None:
        self.name = name
        self.is_open = is_open

    def open(self) -> str:
        self.is_open = True
        return f"{self.name} opened"

    def close(self) -> str:
        self.is_open = False
        return f"{self.name} closed"


class BoomBarrier(Gate):
    def __init__(self, tag_in_range: str | None) -> None:
        super().__init__("barrier", False)
        self.tag_in_range = tag_in_range

    def read_tag(self) -> str | None:
        return self.tag_in_range


class VisitorKiosk:
    def print_pass(self, visitor: str, flat: str) -> str:
        return f"pass printed for {visitor}, visiting {flat}"


def resident_entry(gate: TagGate) -> str:
    tag = gate.read_tag()
    if tag is None:
        return "no resident tag in range"
    return f"resident tag {tag}: {gate.open()}"


def night_lockdown(barriers: list[Barrier]) -> None:
    for barrier in barriers:
        print(f"night lockdown: {barrier.close()}")


car_gate = BoomBarrier("TAG-1042")
foot_gate = Gate("pedestrian gate", True)
desk: VisitorDesk = VisitorKiosk()
print(resident_entry(car_gate))
print(desk.print_pass("Meera", "B-204"))
night_lockdown([car_gate, foot_gate])  # only barriers: the kiosk has no close()
print(f"pedestrian gate at the end: {'open' if foot_gate.is_open else 'closed'}")

In Python: The roles are typing.Protocol classes, matched by structure. Gate and BoomBarrier never name a role, yet a type checker refuses the kiosk in the lockdown's list, because it has no close().

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

/** @typedef {{ open(): string, close(): string }} Barrier */
/** @typedef {{ readTag(): string | null }} TagReader a resident's tag in range, or null */
/** @typedef {TagReader & Barrier} TagGate two roles, composed */
/** @typedef {{ printPass(visitor: string, flat: string): string }} VisitorDesk */

class Gate {
  constructor(name, isOpen) {
    this.name = name;
    this.isOpen = isOpen;
  }

  open() {
    this.isOpen = true;
    return `${this.name} opened`;
  }

  close() {
    this.isOpen = false;
    return `${this.name} closed`;
  }
}

class BoomBarrier extends Gate {
  #tagInRange;

  constructor(tagInRange) {
    super("barrier", false);
    this.#tagInRange = tagInRange;
  }

  readTag() {
    return this.#tagInRange;
  }
}

class VisitorKiosk {
  printPass(visitor, flat) {
    return `pass printed for ${visitor}, visiting ${flat}`;
  }
}

/** @param {TagGate} gate */
function residentEntry(gate) {
  const tag = gate.readTag();
  return tag === null ? "no resident tag in range" : `resident tag ${tag}: ${gate.open()}`;
}

/** @param {Barrier[]} barriers */
function nightLockdown(barriers) {
  for (const barrier of barriers) {
    console.log(`night lockdown: ${barrier.close()}`);
  }
}

const carGate = new BoomBarrier("TAG-1042");
const footGate = new Gate("pedestrian gate", true);
/** @type {VisitorDesk} */
const desk = new VisitorKiosk();
console.log(residentEntry(carGate));
console.log(desk.printPass("Meera", "B-204"));
nightLockdown([carGate, footGate]); // only barriers: the kiosk has no close()
console.log(`pedestrian gate at the end: ${footGate.isOpen ? "open" : "closed"}`);

In JavaScript: JavaScript has no interfaces, so the roles are JSDoc types that editors and tsc --checkJs read. Nothing checks them while the program runs, so a kiosk in the lockdown's list would fail only at its close() call.

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.List;

public class Main {
  interface Barrier {
    String open();

    String close();
  }

  interface TagReader {
    String readTag(); // a resident's tag in range, or null
  }

  interface TagGate extends TagReader, Barrier {} // two roles, composed

  interface VisitorDesk {
    String printPass(String visitor, String flat);
  }

  static class Gate implements Barrier {
    final String name;
    boolean isOpen;

    Gate(String name, boolean isOpen) {
      this.name = name;
      this.isOpen = isOpen;
    }

    @Override
    public String open() {
      isOpen = true;
      return name + " opened";
    }

    @Override
    public String close() {
      isOpen = false;
      return name + " closed";
    }
  }

  static class BoomBarrier extends Gate implements TagGate {
    private final String tagInRange;

    BoomBarrier(String tagInRange) {
      super("barrier", false);
      this.tagInRange = tagInRange;
    }

    @Override
    public String readTag() {
      return tagInRange;
    }
  }

  static class VisitorKiosk implements VisitorDesk {
    @Override
    public String printPass(String visitor, String flat) {
      return "pass printed for " + visitor + ", visiting " + flat;
    }
  }

  static String residentEntry(TagGate gate) {
    String tag = gate.readTag();
    return tag == null ? "no resident tag in range" : "resident tag " + tag + ": " + gate.open();
  }

  static void nightLockdown(List<Barrier> barriers) {
    barriers.forEach(barrier -> System.out.println("night lockdown: " + barrier.close()));
  }

  public static void main(String[] args) {
    BoomBarrier carGate = new BoomBarrier("TAG-1042");
    Gate footGate = new Gate("pedestrian gate", true);
    System.out.println(residentEntry(carGate));
    System.out.println(new VisitorKiosk().printPass("Meera", "B-204"));
    nightLockdown(List.of(carGate, footGate)); // only barriers: the kiosk has no close()
    System.out.println("pedestrian gate at the end: " + (footGate.isOpen ? "open" : "closed"));
  }
}

In Java: A class plays a role only when it says so. BoomBarrier inherits open and close from Gate and declares implements TagGate, and List<Barrier> refuses a VisitorKiosk when the program is compiled.

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 <optional>
#include <print>
#include <string>
#include <utility>
#include <vector>

struct Barrier {
  virtual ~Barrier() = default;
  virtual std::string open() = 0;
  virtual std::string close() = 0;
};

struct TagReader {
  virtual ~TagReader() = default;
  // A resident's tag in range, or none.
  virtual std::optional<std::string> readTag() const = 0;
};

struct TagGate : TagReader, virtual Barrier {}; // two roles, composed

struct VisitorDesk {
  virtual ~VisitorDesk() = default;
  virtual std::string printPass(const std::string &visitor,
                                const std::string &flat) const = 0;
};

struct Gate : virtual Barrier {
  Gate(std::string name, bool isOpen) : name(std::move(name)), isOpen(isOpen) {}
  std::string open() override {
    isOpen = true;
    return name + " opened";
  }
  std::string close() override {
    isOpen = false;
    return name + " closed";
  }
  std::string name;
  bool isOpen;
};

class BoomBarrier : public Gate, public TagGate {
public:
  explicit BoomBarrier(std::optional<std::string> tagInRange)
      : Gate("barrier", false), tagInRange_(std::move(tagInRange)) {}
  std::optional<std::string> readTag() const override { return tagInRange_; }

private:
  std::optional<std::string> tagInRange_;
};

struct VisitorKiosk : VisitorDesk {
  std::string printPass(const std::string &visitor,
                        const std::string &flat) const override {
    return "pass printed for " + visitor + ", visiting " + flat;
  }
};

std::string residentEntry(TagGate &gate) {
  const auto tag = gate.readTag();
  return tag ? "resident tag " + *tag + ": " + gate.open()
             : "no resident tag in range";
}

void nightLockdown(const std::vector<Barrier *> &barriers) {
  for (Barrier *barrier : barriers) {
    std::println("night lockdown: {}", barrier->close());
  }
}

int main() {
  BoomBarrier carGate("TAG-1042");
  Gate footGate("pedestrian gate", true);
  std::println("{}", residentEntry(carGate));
  std::println("{}", VisitorKiosk{}.printPass("Meera", "B-204"));
  // only barriers: the kiosk has no close()
  nightLockdown({&carGate, &footGate});
  std::println("pedestrian gate at the end: {}",
               footGate.isOpen ? "open" : "closed");
}

In C++: Barrier is a virtual base, so a BoomBarrier, which is both a Gate and a TagGate, holds one Barrier, whose open and close come from Gate.

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

var carGate = new BoomBarrier("TAG-1042");
var footGate = new Gate("pedestrian gate", true);
IVisitorDesk desk = new VisitorKiosk();
Console.WriteLine(ResidentEntry(carGate));
Console.WriteLine(desk.PrintPass("Meera", "B-204"));
NightLockdown([carGate, footGate]); // only barriers: the kiosk has no Close()
Console.WriteLine($"pedestrian gate at the end: {(footGate.IsOpen ? "open" : "closed")}");

static string ResidentEntry(ITagGate gate)
{
    string? tag = gate.ReadTag();
    return tag is null ? "no resident tag in range" : $"resident tag {tag}: {gate.Open()}";
}

static void NightLockdown(List<IBarrier> barriers)
{
    foreach (IBarrier barrier in barriers)
    {
        Console.WriteLine($"night lockdown: {barrier.Close()}");
    }
}

interface IBarrier
{
    string Open();
    string Close();
}

interface ITagReader
{
    string? ReadTag(); // a resident's tag in range, or null
}

interface ITagGate : ITagReader, IBarrier { } // two roles, composed

interface IVisitorDesk
{
    string PrintPass(string visitor, string flat);
}

class Gate(string name, bool isOpen) : IBarrier
{
    public bool IsOpen { get; private set; } = isOpen;

    public string Open()
    {
        IsOpen = true;
        return $"{name} opened";
    }

    public string Close()
    {
        IsOpen = false;
        return $"{name} closed";
    }
}

class BoomBarrier(string? tagInRange) : Gate("barrier", false), ITagGate
{
    public string? ReadTag() => tagInRange;
}

class VisitorKiosk : IVisitorDesk
{
    public string PrintPass(string visitor, string flat) =>
        $"pass printed for {visitor}, visiting {flat}";
}

In C#: Interface names start with I, as .NET's naming guidelines ask. The primary constructors of Gate and BoomBarrier keep their parameters as the objects' private state.

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 classes; a struct of function pointers for each role would be another design.

PHP 8.5 · main.php

<?php

declare(strict_types=1);

interface Barrier
{
    public function open(): string;

    public function close(): string;
}

interface TagReader
{
    public function readTag(): ?string; // a resident's tag in range, or null
}

interface TagGate extends TagReader, Barrier {} // two roles, composed

interface VisitorDesk
{
    public function printPass(string $visitor, string $flat): string;
}

class Gate implements Barrier
{
    public function __construct(private string $name, public bool $isOpen) {}

    public function open(): string
    {
        $this->isOpen = true;
        return "{$this->name} opened";
    }

    public function close(): string
    {
        $this->isOpen = false;
        return "{$this->name} closed";
    }
}

final class BoomBarrier extends Gate implements TagGate
{
    public function __construct(private ?string $tagInRange)
    {
        parent::__construct('barrier', false);
    }

    public function readTag(): ?string
    {
        return $this->tagInRange;
    }
}

final class VisitorKiosk implements VisitorDesk
{
    public function printPass(string $visitor, string $flat): string
    {
        return "pass printed for {$visitor}, visiting {$flat}";
    }
}

function residentEntry(TagGate $gate): string
{
    $tag = $gate->readTag();
    return $tag === null ? 'no resident tag in range' : "resident tag {$tag}: {$gate->open()}";
}

function nightLockdown(Barrier ...$barriers): void
{
    foreach ($barriers as $barrier) {
        echo "night lockdown: {$barrier->close()}\n";
    }
}

$carGate = new BoomBarrier('TAG-1042');
$footGate = new Gate('pedestrian gate', true);
echo residentEntry($carGate), "\n";
echo (new VisitorKiosk())->printPass('Meera', 'B-204'), "\n";
nightLockdown($carGate, $footGate); // only barriers: the kiosk has no close()
echo 'pedestrian gate at the end: ', $footGate->isOpen ? 'open' : 'closed', "\n";

In PHP: TagGate extends two interfaces, which PHP allows for interfaces only. nightLockdown takes Barrier ...$barriers, so each argument's type is checked when the call is made.

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

trait Barrier {
    fn open(&mut self) -> String;
    fn close(&mut self) -> String;
}

trait TagReader {
    fn read_tag(&self) -> Option<String>; // a resident's tag in range, or None
}

trait TagGate: TagReader + Barrier {} // two roles, composed
impl<T: TagReader + Barrier> TagGate for T {}

trait VisitorDesk {
    fn print_pass(&self, visitor: &str, flat: &str) -> String;
}

struct Gate<R> {
    name: &'static str,
    is_open: bool,
    reader: R,
}

impl<R> Barrier for Gate<R> {
    fn open(&mut self) -> String {
        self.is_open = true;
        format!("{} opened", self.name)
    }

    fn close(&mut self) -> String {
        self.is_open = false;
        format!("{} closed", self.name)
    }
}

struct TagInRange(Option<&'static str>);

impl TagReader for Gate<TagInRange> {
    fn read_tag(&self) -> Option<String> {
        self.reader.0.map(String::from)
    }
}

struct VisitorKiosk;

impl VisitorDesk for VisitorKiosk {
    fn print_pass(&self, visitor: &str, flat: &str) -> String {
        format!("pass printed for {visitor}, visiting {flat}")
    }
}

fn resident_entry(gate: &mut impl TagGate) -> String {
    match gate.read_tag() {
        Some(tag) => format!("resident tag {tag}: {}", gate.open()),
        None => "no resident tag in range".to_string(),
    }
}

fn night_lockdown(barriers: &mut [&mut dyn Barrier]) {
    for barrier in barriers.iter_mut() {
        println!("night lockdown: {}", barrier.close());
    }
}

fn main() {
    let mut car_gate = Gate {
        name: "barrier",
        is_open: false,
        reader: TagInRange(Some("TAG-1042")),
    };
    let mut foot_gate = Gate {
        name: "pedestrian gate",
        is_open: true,
        reader: (),
    };
    println!("{}", resident_entry(&mut car_gate));
    println!("{}", VisitorKiosk.print_pass("Meera", "B-204"));
    night_lockdown(&mut [&mut car_gate, &mut foot_gate]); // only barriers: the kiosk has no close()
    let state = if foot_gate.is_open { "open" } else { "closed" };
    println!("pedestrian gate at the end: {state}");
}

In Rust: Rust has no inheritance. The barrier is a Gate whose reader is a TagInRange, and only Gate<TagInRange> implements TagReader, so the pedestrian gate, a Gate<()>, can never reach resident_entry.

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

interface Barrier {
  open(): string;
  close(): string;
}

interface TagReader {
  readTag(): string | null; // a resident's tag in range, or null
}

interface TagGate extends TagReader, Barrier {} // two roles, composed

interface VisitorDesk {
  printPass(visitor: string, flat: string): string;
}

class Gate implements Barrier {
  readonly name: string;
  isOpen: boolean;

  constructor(name: string, isOpen: boolean) {
    this.name = name;
    this.isOpen = isOpen;
  }

  open(): string {
    this.isOpen = true;
    return `${this.name} opened`;
  }

  close(): string {
    this.isOpen = false;
    return `${this.name} closed`;
  }
}

class BoomBarrier extends Gate implements TagGate {
  readonly #tagInRange: string | null;

  constructor(tagInRange: string | null) {
    super("barrier", false);
    this.#tagInRange = tagInRange;
  }

  readTag(): string | null {
    return this.#tagInRange;
  }
}

class VisitorKiosk implements VisitorDesk {
  printPass(visitor: string, flat: string): string {
    return `pass printed for ${visitor}, visiting ${flat}`;
  }
}

function residentEntry(gate: TagGate): string {
  const tag = gate.readTag();
  return tag === null ? "no resident tag in range" : `resident tag ${tag}: ${gate.open()}`;
}

function nightLockdown(barriers: Barrier[]): void {
  for (const barrier of barriers) {
    console.log(`night lockdown: ${barrier.close()}`);
  }
}

const carGate = new BoomBarrier("TAG-1042");
const footGate = new Gate("pedestrian gate", true);
const desk: VisitorDesk = new VisitorKiosk();
console.log(residentEntry(carGate));
console.log(desk.printPass("Meera", "B-204"));
nightLockdown([carGate, footGate]); // only barriers: the kiosk has no close()
console.log(`pedestrian gate at the end: ${footGate.isOpen ? "open" : "closed"}`);

In TypeScript: Interfaces are structural, like Python's protocols, so BoomBarrier would be a TagGate even without implements; implements asks the compiler to check the class against the role where it is declared.

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"

type Barrier interface {
	Open() string
	Close() string
}

type TagReader interface {
	ReadTag() (tag string, ok bool) // a resident's tag in range, or ok false
}

// TagGate is two roles, composed.
type TagGate interface {
	TagReader
	Barrier
}

type VisitorDesk interface {
	PrintPass(visitor, flat string) string
}

type Gate struct {
	name   string
	isOpen bool
}

func (g *Gate) Open() string {
	g.isOpen = true
	return g.name + " opened"
}

func (g *Gate) Close() string {
	g.isOpen = false
	return g.name + " closed"
}

type BoomBarrier struct {
	Gate
	tagInRange string
}

func (b *BoomBarrier) ReadTag() (string, bool) {
	return b.tagInRange, b.tagInRange != ""
}

type VisitorKiosk struct{}

func (VisitorKiosk) PrintPass(visitor, flat string) string {
	return fmt.Sprintf("pass printed for %s, visiting %s", visitor, flat)
}

func residentEntry(gate TagGate) string {
	tag, ok := gate.ReadTag()
	if !ok {
		return "no resident tag in range"
	}
	return fmt.Sprintf("resident tag %s: %s", tag, gate.Open())
}

func nightLockdown(barriers []Barrier) {
	for _, barrier := range barriers {
		fmt.Println("night lockdown: " + barrier.Close())
	}
}

func main() {
	carGate := &BoomBarrier{Gate{"barrier", false}, "TAG-1042"}
	footGate := &Gate{"pedestrian gate", true}
	var desk VisitorDesk = VisitorKiosk{}
	fmt.Println(residentEntry(carGate))
	fmt.Println(desk.PrintPass("Meera", "B-204"))
	nightLockdown([]Barrier{carGate, footGate}) // only barriers: the kiosk has no Close()
	state := "closed"
	if footGate.isOpen {
		state = "open"
	}
	fmt.Println("pedestrian gate at the end: " + state)
}

In Go: Interfaces are satisfied without being named, and TagGate embeds TagReader and Barrier as io.ReadWriter embeds io.Reader and io.Writer. ReadTag reports no tag with a second result, false, instead of a null.

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

protocol Barrier {
  func open() -> String
  func close() -> String
}

protocol TagReader {
  func readTag() -> String?  // a resident's tag in range, or nil
}

typealias TagGate = TagReader & Barrier  // two roles, composed

protocol VisitorDesk {
  func printPass(for visitor: String, visiting flat: String) -> String
}

class Gate: Barrier {
  let name: String
  private(set) var isOpen: Bool

  init(name: String, isOpen: Bool) {
    self.name = name
    self.isOpen = isOpen
  }

  func open() -> String {
    isOpen = true
    return "\(name) opened"
  }

  func close() -> String {
    isOpen = false
    return "\(name) closed"
  }
}

final class BoomBarrier: Gate, TagReader {
  private let tagInRange: String?

  init(tagInRange: String?) {
    self.tagInRange = tagInRange
    super.init(name: "barrier", isOpen: false)
  }

  func readTag() -> String? { tagInRange }
}

struct VisitorKiosk: VisitorDesk {
  func printPass(for visitor: String, visiting flat: String) -> String {
    "pass printed for \(visitor), visiting \(flat)"
  }
}

func residentEntry(_ gate: any TagGate) -> String {
  guard let tag = gate.readTag() else { return "no resident tag in range" }
  return "resident tag \(tag): \(gate.open())"
}

func nightLockdown(_ barriers: [any Barrier]) {
  for barrier in barriers {
    print("night lockdown: \(barrier.close())")
  }
}

let carGate = BoomBarrier(tagInRange: "TAG-1042")
let footGate = Gate(name: "pedestrian gate", isOpen: true)
let desk: any VisitorDesk = VisitorKiosk()
print(residentEntry(carGate))
print(desk.printPass(for: "Meera", visiting: "B-204"))
nightLockdown([carGate, footGate])  // only barriers: the kiosk has no close()
print("pedestrian gate at the end: \(footGate.isOpen ? "open" : "closed")")

In Swift: TagReader & Barrier is a protocol composition, so TagGate needs no protocol of its own. Gate is a class, because closing a struct held in an [any Barrier] array would close only the array's copy.

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

# Roles, by what each caller uses; Ruby checks none of them before the program runs:
# Barrier: open and close. TagReader: read_tag, a resident's tag in range, or nil.
# TagGate: two roles, composed. VisitorDesk: print_pass.

# A barrier that people or cars pass: it plays Barrier.
class Gate
  def initialize(name, open)
    @name = name
    @open = open
  end

  def open?
    @open
  end

  def open
    @open = true
    "#{@name} opened"
  end

  def close
    @open = false
    "#{@name} closed"
  end
end

# The car gate: a Gate with its own reader, so it plays TagGate.
class BoomBarrier < Gate
  def initialize(tag_in_range)
    super('barrier', false)
    @tag_in_range = tag_in_range
  end

  def read_tag
    @tag_in_range
  end
end

# The guard's desk: it plays VisitorDesk.
class VisitorKiosk
  def print_pass(visitor, flat)
    "pass printed for #{visitor}, visiting #{flat}"
  end
end

def resident_entry(gate)
  tag = gate.read_tag
  return 'no resident tag in range' if tag.nil?

  "resident tag #{tag}: #{gate.open}"
end

def night_lockdown(barriers)
  barriers.each { |barrier| puts "night lockdown: #{barrier.close}" }
end

car_gate = BoomBarrier.new('TAG-1042')
foot_gate = Gate.new('pedestrian gate', true)
desk = VisitorKiosk.new
puts resident_entry(car_gate)
puts desk.print_pass('Meera', 'B-204')
night_lockdown([car_gate, foot_gate]) # only barriers: the kiosk has no close
puts "pedestrian gate at the end: #{foot_gate.open? ? 'open' : 'closed'}"

In Ruby: Ruby has no interface declarations, so the roles are written down as comments and a method call is the only check. open? says whether the gate is open; open opens it.

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

interface Barrier {
    fun open(): String

    fun close(): String
}

interface TagReader {
    fun readTag(): String? // a resident's tag in range, or null
}

interface TagGate :
    TagReader,
    Barrier // two roles, composed

interface VisitorDesk {
    fun printPass(
        visitor: String,
        flat: String,
    ): String
}

open class Gate(
    private val name: String,
    isOpen: Boolean,
) : Barrier {
    var isOpen = isOpen
        private set

    override fun open(): String {
        isOpen = true
        return "$name opened"
    }

    override fun close(): String {
        isOpen = false
        return "$name closed"
    }
}

class BoomBarrier(
    private val tagInRange: String?,
) : Gate("barrier", false),
    TagGate {
    override fun readTag(): String? = tagInRange
}

class VisitorKiosk : VisitorDesk {
    override fun printPass(
        visitor: String,
        flat: String,
    ): String = "pass printed for $visitor, visiting $flat"
}

fun residentEntry(gate: TagGate): String {
    val tag = gate.readTag() ?: return "no resident tag in range"
    return "resident tag $tag: ${gate.open()}"
}

fun nightLockdown(barriers: List<Barrier>) {
    for (barrier in barriers) {
        println("night lockdown: ${barrier.close()}")
    }
}

fun main() {
    val carGate = BoomBarrier("TAG-1042")
    val footGate = Gate("pedestrian gate", true)
    val desk: VisitorDesk = VisitorKiosk()
    println(residentEntry(carGate))
    println(desk.printPass("Meera", "B-204"))
    nightLockdown(listOf(carGate, footGate)) // only barriers: the kiosk has no close()
    println("pedestrian gate at the end: ${if (footGate.isOpen) "open" else "closed"}")
}

In Kotlin: TagGate composes the two roles in its supertype list. Gate is open, so BoomBarrier may extend it, and isOpen has a private setter, so only open() and close() change it.

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

abstract interface class Barrier {
  String open();
  String close();
}

abstract interface class TagReader {
  String? readTag(); // a resident's tag in range, or null
}

abstract interface class TagGate
    implements TagReader, Barrier {} // two roles, composed

abstract interface class VisitorDesk {
  String printPass(String visitor, String flat);
}

class Gate implements Barrier {
  Gate(this.name, this._isOpen);

  final String name;
  bool _isOpen;

  bool get isOpen => _isOpen;

  @override
  String open() {
    _isOpen = true;
    return '$name opened';
  }

  @override
  String close() {
    _isOpen = false;
    return '$name closed';
  }
}

final class BoomBarrier extends Gate implements TagGate {
  BoomBarrier(this._tagInRange) : super('barrier', false);

  final String? _tagInRange;

  @override
  String? readTag() => _tagInRange;
}

final class VisitorKiosk implements VisitorDesk {
  @override
  String printPass(String visitor, String flat) =>
      'pass printed for $visitor, visiting $flat';
}

String residentEntry(TagGate gate) {
  final tag = gate.readTag();
  if (tag == null) return 'no resident tag in range';
  return 'resident tag $tag: ${gate.open()}';
}

void nightLockdown(List<Barrier> barriers) {
  for (final barrier in barriers) {
    print('night lockdown: ${barrier.close()}');
  }
}

void main() {
  final carGate = BoomBarrier('TAG-1042');
  final footGate = Gate('pedestrian gate', true);
  final VisitorDesk desk = VisitorKiosk();
  print(residentEntry(carGate));
  print(desk.printPass('Meera', 'B-204'));
  nightLockdown([carGate, footGate]); // only barriers: the kiosk has no close()
  print('pedestrian gate at the end: ${footGate.isOpen ? 'open' : 'closed'}');
}

In Dart: An abstract interface class can be implemented but not extended outside its library. BoomBarrier extends Gate and implements TagGate, so its open and close are Gate's.

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