Сказка о типизации

В некотором царстве, в некотором государстве жил был царь. Как-то раз объявил царь всему народу — «Кто решит три моих задачки, тот сам сможет царём стать». И даже контракт метода опубликовал, всё честь по чести.

public interface ЦарёвУказ1844 {    interface РешилВсеЗадачи {}    void setЦарь(Человек<? extends РешилВсеЗадачи> новыйЦарь);   Человек<?> getЦарь(); }

Пришёл к царю кузнец, в разных делах дока, и говорит: «Давай свои задачки»

Царь руки потирает и говорит: «Ну что ж, изволь. Вот моя первая задачка»

Задача о боровиках

«Хочу в указах устанавливать разрешённый сезон сбора боровиков. Скажем, весной и осенью. Могу написать так:

enum ВремяГода { ВЕСНА, ОСЕНЬ, ЗИМА, ЛЕТО }  void идтиСобиратьБоровики(ВремяГода времяГода) {      if (!(времяГода == ОСЕНЬ || времяГода == ВЕСНА))         throw new RuntimeException("Запрещено!"); }

Но тогда ошибка появляется только в рантайме. А я хочу, чтобы ещё на этапе компиляции нельзя было пойти собирать боровики зимой, чтоб прямо в указе было ясно — когда можно, когда нельзя»

«Ну, – говорит кузнец, – сделай разные классы и два перегруженных метода, вот так как-то»

sealed interface ВремяГода {}  final class Зима implements ВремяГода {} final class Весна implements ВремяГода {} final class Лето implements ВремяГода {} final class Осень implements ВремяГода {}  void идтиСобиратьБоровики(Весна весна) {} void идтиСобиратьБоровики(Осень осень) {}

«Теперь если зимой попытаться пойти – не скомпилируется»

«А если сезоны менять – это мне придётся новые методы дописывать или эти удалять? Не хочу. Хочу один метод!»

«Ежели один метод, тогда можно маркерный интерфейс завести и временам года назначать»

interface МожноСобиратьБоровики {}  final class Зима implements ВремяГода {} final class Весна implements ВремяГода, МожноСобиратьБоровики {} final class Лето implements ВремяГода {} final class Осень implements ВремяГода, МожноСобиратьБоровики {}  <ВГ extends ВремяГода & МожноСобиратьБоровики>    void идтиСобиратьБоровики(ВГ времяГода) {}

«Уже лучше, – говорит царь. – Только неудобно, что надо навешивать интерфейсы сезонам. Можно как-то так сделать, чтобы в одном месте перечень был? Редактировать проще»

«Изволь, – говорит кузнец, – можно и перечень, но тогда чутка посложнее выйдет»

static class ВремяГода<X> {}   interface Зима {}  interface Весна {}  interface Лето {}  interface Осень {}  interface МожноСобиратьБоровики extends Зима, Весна {}  static void идтиСобиратьБоровики(ВремяГода<? super МожноСобиратьБоровики> времяГода) {}

«Эх, теперь времена года не sealed, – вздохнул царь»

«Ну ты уж определись, надёжа государь, тебе боровики или высокий штиль кода»

«Ладно, ладно, с этой задачей справился»

Задача о Кощее

«Вторая задачка такая. От царства кощеева поступил заказ на большое количество иголок, яиц, уток, зайцев и сундуков. Надо выдавать всё это пачками и в правильном порядке — сначала сундук, потом заяц, и в конце – игла. Но если я сделаю как-то так.»

enum КощеевоБарахло { Игла, Яйцо, Утка, Заяц, Сундук }  List<КощеевоБарахло> выдатьЗаказ() 

«То никто не помешает нерадивым работникам нарушить порядок и положить зайца в яйцо»

return Arrays.asList(Сундук, Яйцо, Заяц);

«А то и вообще – два сундука подсунуть. А хочется такой список возвращать, чтобы порядок на этапе компиляции гарантировался. А, ну и пропуски возможны. Если зайцы вдруг закончатся, можно уток сразу в сундуки.»

Задумался кузнец.

«Так, говорит, начнём потихоньку ковать. Чтобы на этапе компиляции сравнивать размеры, нам нужны для них отдельные типы, связанные в иерархию. Вот они»

interface Размер1 { }  interface Размер2 extends Размер1 { }  interface Размер3 extends Размер2 { }  interface Размер4 extends Размер3 { }  interface Размер5 extends Размер4 { }

«Теперь заведём вспомогательные интерфейсы»

interface Размер<Р> { }    interface МеньшеЧем<Р> { }

«Смысл простой – ими будем предметы помечать. И тогда, например, тип Размер<? super Размер3> предмет опишет любой предмет с размером от Размер1 до Размер3. Теперь кощеево барахло пометим»

sealed interface КощеевоБарахло { }  final class Игла implements КощеевоБарахло, Размер<Размер1>, МеньшеЧем<Размер2> { } final class Яйцо implements КощеевоБарахло, Размер<Размер2>, МеньшеЧем<Размер3> { } final class Утка implements КощеевоБарахло, Размер<Размер3>, МеньшеЧем<Размер4> { } final class Заяц implements КощеевоБарахло, Размер<Размер4>, МеньшеЧем<Размер5> { } final class Сундук implements КощеевоБарахло, Размер<Размер5> { }

«Предметы удобнее парами сравнивать, да и твоим работникам сподручнее один предмет в другой положить, а не всеми сразу жонглировать. Поэтому сделаем такой метод, который принимает два предмета, и только таких, где второй – меньше первого.»

public <РазмерПредмета,         Предмет extends КощеевоБарахло & Размер<РазмерПредмета>,         ПредметМеньше extends КощеевоБарахло & МеньшеЧем<? super РазмерПредмета>         > void больше(Предмет предмет, ПредметМеньше поменьше) {}      public static void main(String[] args) {   // больше(new Утка(), new Заяц()); // ошибка компиляции   // больше(new Заяц(), new Заяц()); // ошибка компиляции    больше(new Заяц(), new Утка());  // ок }

«А теперь делаем связный список, но такой, чтобы верхний элемент мог быть только больше следующего элемента.»

class SortedList<BaseType, HeadType extends BaseType> {      private HeadType head;      private SortedList<BaseType, ?> tail;      public final int size;       private SortedList(HeadType head, SortedList<BaseType, ?> tail) {          this.head = head;          this.tail = tail;          this.size = 1 + (tail == null ? 0 : tail.size);      }       public BaseType get(int idx) {          assert idx >= 0 && idx < size;          return getUnchecked(idx);      }       private BaseType getUnchecked(int idx) {          return idx == 0 ? head : tail.getUnchecked(idx - 1);      }  }

«А чего это ты на англицкий переключился?»

«Ваше величество, не говори под руку, а то эксепшном зашибёт. Дальше смотри что будет»

public <РазмерПредмета,          Предмет extends КощеевоБарахло & Размер<РазмерПредмета>         >           SortedList<КощеевоБарахло, Предмет> положить(Предмет предмет) {               return new SortedList<>(предмет, null);  }  public <РазмерПредмета,          Предмет extends КощеевоБарахло & Размер<РазмерПредмета>,          ПредметМеньше extends КощеевоБарахло & МеньшеЧем<? super РазмерПредмета>          >           SortedList<КощеевоБарахло, Предмет> внутрь(             Предмет предмет,              SortedList<КощеевоБарахло, ПредметМеньше> предметПоменьше         ) {                return new SortedList<>(предмет, предметПоменьше);  }  SortedList<КощеевоБарахло, ?> выдатьЗаказ() {      var игла = new Игла();      var заяц = new Заяц();      var утка = new Утка();      var сундук = new Сундук();      var яйцо = new Яйцо();       return внутрь(сундук, внутрь(заяц, внутрь(утка, внутрь(яйцо, положить(игла)))));  }

«Вот и всё. Теперь только в таком порядке и можно отдавать заказ. А если чего не хватает – можно пропустить»

«Ладно, кузнец, тут ты тоже справился. Вот тебе последняя задача.»

Задача о перстне

«Кто-то стащил у меня перстень. И никак не могу понять – кто. Что нам известно:

• Перстень тяжёлый, трансурановый

• Вор был один

• Лекарь и Писарь знают, где перстень лежать должен

• Ключ от этих палат есть у Писаря и у Попа

• Лекарь и Писарь щуплые, слабые

• Конюх должен Лекарю, Поп должен Князю, а Князь должен Писарю

• Лекарь дружит с Князем, Конюх дружит с Попом

Хочу знать, кто подлец, и чтобы ещё на этапе компиляции – так точно не отвертятся.»

«Государь-батюшка, а не проще ли Prolog для этой цели взять?»

«Ты делай давай. А не можешь – так пошёл вон с глаз моих.»

Усмехнулся кузнец, и давай размышлять.

«Так, сначала признаки раскидаем. Кто, кому, куда и как.»

interface МожетПоднятьТяжесть { } interface ИмеетКлюч { } interface Друг<X> { } interface ЗнаетГдеПерстень { } interface ДалВзаймы<X> { } interface Должен<X> { }  class Конюх implements Должен<Лекарь>, МожетПоднятьТяжесть, Друг<Поп> { } class Лекарь implements ЗнаетГдеПерстень, Друг<Князь>, ДалВзаймы<Конюх> { } class Поп implements Друг<Конюх>, Должен<Князь>, ИмеетКлюч, МожетПоднятьТяжесть { } class Писарь implements ИмеетКлюч, ЗнаетГдеПерстень, ДалВзаймы<Князь> { } class Князь implements Друг<Лекарь>, МожетПоднятьТяжесть, Должен<Писарь>, ДалВзаймы<Поп> { }

«Теперь будем составлять метод, который примет только одного из них – преступника. Но вариантов несколько, а объединений типов в Java пока не завезли, поэтому хочешь не хочешь, а придётся несколько методов делать. Понял?»

«Понял, понял. А компилятор не запутается, ежели generic тип будет? Наругает ещё, что из-за erasure типы одинаковые.»

«Наругает, коли не схитрим. А мы схитрим. Начнём с очевидной версии. Тот преступник, кто и сильный, и знает где перстень, и ключ имеет.»

public <I extends МожетПоднятьТяжесть & ИмеетКлюч & ЗнаетГдеПерстень>    void преступник(I вор, Double x) {}

«А последний аргумент зачем?»

«А вот потом увидишь. Забиваем всех пятерых, пробуем скомпилировать»

преступник(князь, null);  преступник(поп, null);  преступник(писарь, null);  преступник(лекарь, null);  преступник(конюх, null);

«Все строчки с ошибками, а значит версия наша провалилась. Но мы её пока оставим, чтобы честно было. Проверим другую версию: что если вынес кто-то сильный, а про перстень у друга узнал и ключ у него же взял?»

public static <         H extends ИмеетКлюч & ЗнаетГдеПерстень,         I extends МожетПоднятьТяжесть & Друг<H>     > void преступник(I вор, Short x) {}

«Ах вот зачем тебе второй аргумент, это чтобы компилятор видел у них разные сигнатуры и не донимал.»

«А ты шаришь. Но по прежнему все строчки у нас не компилируются.

Тогда другое предположение. Преступник сам сильный, друг ему про перстень рассказал, а ключ он у должника выклянчил»

public static <     I extends МожетПоднятьТяжесть         & ДалВзаймы<? extends ИмеетКлюч>         & Друг<? extends ЗнаетГдеПерстень> > void преступник(I вор, Integer i) {}

«Ага, а вот и строчка компилирующаяся — преступник(князь, null). Значит перстень князь стащил. От лекаря про перстень узнал, а у попа ключ взял.»

«Вот я так и знал, что он, подлец, за всем стоит. То-то смотрю – ходит довольный, аж светится!»

Награда

«Ну что ж, кузнец, три задачи ты честно решил. Интерфейс я тебе присваиваю с честью»

public class Кузнец implements Человек<ЦарёвУказ1844.РешилВсеЗадачи> {}

«Интерфейс это хорошо, а теперь давай место на троне уступай»

«Пожалуйста, пожалуйста, вот вам метод, вызывайте»

ЦарёвУказ1844 указ1844 = new ЦарёвУказ1844Impl();  Кузнец кузнец = new Кузнец();  указ1844.setЦарь(кузнец);  Exception in thread "main" java.lang.RuntimeException: Не по сеньке шапка  at ЦарёвУказ1844Impl.setЦарь(ЦарёвУказ1844Impl.java:15)  at Награда.main(Награда.java:12)

«Это ещё что, – нахмурился кузнец»

«А это детали реализации, родной. Я ж не совсем с ума сошёл, чтобы кому попало царство своё отдавать. Ну и подстраховался немножко, предусловия разумные поставил»

@Override public void setЦарь(Человек<? extends РешилВсеЗадачи> новыйЦарь) {      if (!((Человек<?>)новыйЦарь instanceof Царь)) {         throw new RuntimeException("Не по сеньке шапка");     }      царь = новыйЦарь; }

«Что-то я не понял – а как ты вообще этот метод с собой вызовешь? Ты же задачи не решил, у тебя интерфейс нереализован!»

указ1844.setЦарь(царь);  java: incompatible types:  Царь cannot be converted to Человек<? extends ЦарёвУказ1844.РешилВсеЗадачи>

«Вот ты смешной кузнец, – хохочет царь, – а reflection на что?»

ЦарёвУказ1844.class     .getDeclaredMethod("setЦарь", Человек.class)     .invoke(указ1844, царь);

Кузнец кое-как глаза обратно впучил, мозг в кучу собрал, и сказал, головой качая:

«Нехорошо это, царь-батюшка, контракт не соблюдать.»

«Ты поучи меня тут ещё, – рассердился царь, – вали, пока цел»

Кузнец плечами пожал да и пошёл куда глаза глядят. Говорят, на Кипре его видели, в стартапе куёт криптоподковы, не тужит. А царь сам запутался в своих контрактах да и наступил на exception. Ходит теперь с фингалом, смурной.

Вот и сказочке конец, а кто слушал — молодец.