Spotting an Interface Segregation Violation

from abc import ABC, abstractmethod


class Worker(ABC):
    @abstractmethod
    def work(self): ...

    @abstractmethod
    def eat(self): ...

    @abstractmethod
    def sleep(self): ...


class Human(Worker):
    def work(self):
        return "Human assembles a chair"

    def eat(self):
        return "Human has lunch"

    def sleep(self):
        return "Human sleeps"


class Robot(Worker):
    def work(self):
        return "Robot assembles a chair"

    def eat(self):
        raise NotImplementedError("robots do not eat")

    def sleep(self):
        raise NotImplementedError("robots do not sleep")


def lunch_break(workers):
    for worker in workers:
        try:
            print(worker.eat())
        except NotImplementedError as error:
            print(f"NotImplementedError: {error}")


lunch_break([Human(), Robot()])

import java.util.List;

public class IspWorker {
    static void lunchBreak(List<Worker> workers) {
        for (Worker worker : workers) {
            try {
                System.out.println(worker.eat());
            } catch (UnsupportedOperationException error) {
                System.out.println("UnsupportedOperationException: " + error.getMessage());
            }
        }
    }

    public static void main(String[] args) {
        lunchBreak(List.of(new Human(), new Robot()));
    }
}

interface Worker {
    String work();

    String eat();

    String sleep();
}

class Human implements Worker {
    public String work() { return "Human assembles a chair"; }

    public String eat() { return "Human has lunch"; }

    public String sleep() { return "Human sleeps"; }
}

class Robot implements Worker {
    public String work() { return "Robot assembles a chair"; }

    public String eat() { throw new UnsupportedOperationException("robots do not eat"); }

    public String sleep() { throw new UnsupportedOperationException("robots do not sleep"); }
}

interface Worker {
  work(): string;
  eat(): string;
  sleep(): string;
}

class Human implements Worker {
  work(): string { return "Human assembles a chair"; }
  eat(): string { return "Human has lunch"; }
  sleep(): string { return "Human sleeps"; }
}

class Robot implements Worker {
  work(): string { return "Robot assembles a chair"; }
  eat(): string { throw new Error("robots do not eat"); }
  sleep(): string { throw new Error("robots do not sleep"); }
}

function lunchBreak(workers: Worker[]): void {
  for (const worker of workers) {
    try {
      console.log(worker.eat());
    } catch (error) {
      console.log(`Error: ${(error as Error).message}`);
    }
  }
}

lunchBreak([new Human(), new Robot()]);