File Compare

 import java.util.List;
 import java.util.Locale;
 import java.util.stream.Stream;
 /* ****************************************
  * 1) CORE LANGUAGE-SPECIFIC TYPES (AXIS Z)
  ******************************************/
 /*
  * 1.A) PART OF SPEECH
  * https://en.wikipedia.org/wiki/Part_of_speech
  */
 //
 // 1.A.I) ENGLISH PART OF SPEECH
 //
 /**
  * Implementing classes consist of one or more part-of-speech tags (each tag provided by a different tagger).
  */
 interface PartOfSpeech {
 }
 class EnglishPartOfSpeech implements PartOfSpeech {
     private final Type1EnglishTag type1Tag = Type1EnglishTag.TO; // SIMPLIFICATION
     private final Type2EnglishTag type2Tag = Type2EnglishTag.GENERAL_PREPOSITION; // SIMPLIFICATION
     boolean isInfinitiveMarker() {
         return type1Tag == Type1EnglishTag.TO && type2Tag == Type2EnglishTag.INFINITIVE_MARKER;
     }
 }
 enum Type1EnglishTag {
     // SIMPLIFICATION (partial content)
     TO // "to" as a preposition or an infinitive marker
 }
 enum Type2EnglishTag {
     // SIMPLIFICATION (partial content)
     GENERAL_PREPOSITION, // e.g. "to" in "I said to him that..."
     INFINITIVE_MARKER // "to", e.g. in "I want to ask."
 }
 //
 // 1.A.II) GERMAN PART OF SPEECH
 //
 class GermanPartOfSpeech implements PartOfSpeech {
     private final Type1GermanTag type1Tag = Type1GermanTag.POSTPOSITION; // SIMPLIFICATION
     boolean isPostposition() {
         return type1Tag == Type1GermanTag.POSTPOSITION;
     }
 }
 enum Type1GermanTag {
     // SIMPLIFICATION (partial content)
     POSTPOSITION, // e.g. "zufolge"
 }
 /*
  * 1.B) CONSTITUENT
  * https://en.wikipedia.org/wiki/Phrase_structure_grammar
  */
 interface ConstituentType {
 }
 enum EnglishConstituentType implements ConstituentType {
     // SIMPLIFICATION (partial content)
     VERB_PHRASE, // e.g. "is doing nice"
     WH_WORD_NOUN_PHRASE // e.g. "whose daughter"
 }
 // enum GermanConstituentType missing as of yet
 /*
  * 1.C) DEPENDENCY
  * https://en.wikipedia.org/wiki/Dependency_grammar
  */
 interface DependencyType {
 }
 enum EnglishDependencyType implements DependencyType {
     // SIMPLIFICATION (partial content)
     NOMINAL_SUBJECT, // e.g. "he" <- "walks" in "He walks."
     PHRASAL_VERB_PARTICLE // e.g. "shut" -> "down" in "It was shut down."
 }
 // enum GermanDependencyType missing as of yet
 /* ***************
  * 2) HELPER TYPES
  *****************/
 interface TextualRange {
     String text();
     int startOffset(); // inclusive
     int endOffset(); // exclusive
 }
 interface Seq {
     /**
      * Stub for <a href="https://www.jooq.org/products/jOOλ/javadoc/0.9.12/org/jooq/lambda/Seq.html#ofType-java.util.str
eam.Stream-java.lang.Class-">Seq.ofType()</a>.
      */
     @SuppressWarnings("unchecked")
     static <T, U> Stream<U> ofType(Stream<? extends T> stream, Class<? extends U> type) {
         return stream.filter(type::isInstance).map(t -> (U) t);
     }
 }
 /**
  * Defines the stage of text processing (AXIS Y).
  */
 enum Stage {
     UNPROCESSED,
     TOKENIZED, // tokens present
     SENTENCIZED, // sentences present
     TAGGED, // parts of speech present
     PARSED // syntax present
 }
 /* ***************************
  * 3) SOLUTION USING SUBTYPING
  *****************************/
 /*
  * 3.A) GENERIC HIERARCHY (AXIS Y OVER X)
  */
 //
 // 3.A.I) UNPROCESSED
 //
 interface LocalizedText extends TextualRange {
     Locale locale();
     default Stage maxStage() {
         return Stage.UNPROCESSED;
     }
 }
 //
 // 3.A.II) WITH TOKENS
 //
 enum TokenType {
     WORD, NUMERIC // SIMPLIFICATION
 }
 interface Token extends TextualRange {
     TokenType tokenType();
 }
 interface TokenizedText extends LocalizedText {
     Stream<? extends Token> tokenStream();
     int tokenCount();
     @Override
     default Stage maxStage() {
         return Stage.TOKENIZED;
     }
 }
 //
 // 3.A.III) WITH SENTENCES
 //
 interface Sentence extends TextualRange {
     List<? extends Token> tokens();
     default Stage stage() {
         return Stage.SENTENCIZED;
     }
 }
 interface SentencizedText extends TokenizedText {
     List<? extends Sentence> sentences();
     @Override
     default Stage maxStage() {
         return Stage.SENTENCIZED;
     }
 }
 //
 // 3.A.IV) WITH PARTS OF SPEECH
 //
-interface TaggedToken<P extends PartOfSpeech> extends Token {
+interface TaggedToken extends Token {
-    P partOfSpeech(); // see section 1.A above
+    PartOfSpeech partOfSpeech(); // see section 1.A above
 }
-interface TaggedSentence<P extends PartOfSpeech> extends Sentence {
+interface TaggedSentence extends Sentence {
     @Override
-    List<? extends TaggedToken<P>> tokens();
+    List<? extends TaggedToken> tokens();
     @Override
     default Stage stage() {
         return Stage.TAGGED;
     }
 }
-interface TaggedText<P extends PartOfSpeech> extends SentencizedText {
+interface TaggedText extends SentencizedText {
     // some (or even all) sentences may remain untagged
-    Stream<? extends TaggedSentence<P>> taggedSentenceStream();
+    Stream<? extends TaggedSentence> taggedSentenceStream();
     @Override
     default Stage maxStage() {
         return Stage.TAGGED;
     }
 }
 //
 // 3.A.V) WITH SYNTAX
 //
-interface Constituent<C extends ConstituentType, P extends PartOfSpeech> {
+interface Constituent {
-    Stream<? extends Constituent<C, P>> childStream();
+    Stream<? extends Constituent> childStream();
 }
-interface ConstituentBranch<C extends ConstituentType, P extends PartOfSpeech> extends Constituent<C, P> {
+interface ConstituentBranch extends Constituent {
-    C type(); // see section 1.B above
+    ConstituentType type(); // see section 1.B above
 }
-interface ConstituentLeaf<C extends ConstituentType, P extends PartOfSpeech> extends Constituent<C, P> {
+interface ConstituentLeaf extends Constituent {
-    TaggedToken<P> token();
+    TaggedToken token();
     @Override
-    default Stream<? extends Constituent<C, P>> childStream() {
+    default Stream<? extends Constituent> childStream() {
         return Stream.empty();
     }
 }
-interface Dependency<D extends DependencyType, P extends PartOfSpeech> {
+interface Dependency {
-    D type(); // see section 1.C above
+    DependencyType type(); // see section 1.C above
-    TaggedToken<P> governor();
+    TaggedToken governor();
-    TaggedToken<P> dependent();
+    TaggedToken dependent();
 }
-interface SentenceSyntax<C extends ConstituentType, D extends DependencyType, P extends PartOfSpeech> {
+interface SentenceSyntax {
-    ConstituentBranch<C, P> constituentTree();
+    ConstituentBranch constituentTree();
-    List<? extends Dependency<D, P>> dependencies();
+    List<? extends Dependency> dependencies();
 }
-interface ParsedSentence<C extends ConstituentType, D extends DependencyType, P extends PartOfSpeech> extends TaggedSent
ence<P> {
+interface ParsedSentence extends TaggedSentence {
-    SentenceSyntax<C, D, P> syntax();
+    SentenceSyntax syntax();
     @Override
     default Stage stage() {
         return Stage.PARSED;
     }
 }
-interface ParsedText<C extends ConstituentType, D extends DependencyType, P extends PartOfSpeech> extends TaggedText<P> 
{
+interface ParsedText extends TaggedText {
     // some (or even all) sentences may remain unparsed
-    Stream<? extends ParsedSentence<C, D, P>> parsedSentenceStream();
+    Stream<? extends ParsedSentence> parsedSentenceStream();
     @Override
     default Stage maxStage() {
         return Stage.PARSED;
     }
 }
+/*
+ * 3.B) LANGUAGE-SPECIFIC HIERARCHY (AXIS Z OVER Y OVER X)
+ */
+//
+// 3.B.I) ENGLISH
+//
+// 3.B.I.a) ENGLISH PARTS OF SPEECH
+interface EnglishTaggedToken extends TaggedToken {
+    @Override
+    EnglishPartOfSpeech partOfSpeech();
+}
+interface EnglishTaggedSentence extends TaggedSentence {
+    @Override
+    List<? extends EnglishTaggedToken> tokens();
+}
+interface EnglishTaggedText extends TaggedText {
+    @Override // some (or even all) sentences may remain untagged
+    default Stream<? extends EnglishTaggedSentence> taggedSentenceStream() {
+        return Seq.ofType(sentences().stream(), EnglishTaggedSentence.class);
+    }
+}
+// 3.B.I.b) ENGLISH SYNTAX
+interface EnglishConstituent extends Constituent {
+    @Override
+    Stream<? extends EnglishConstituent> childStream();
+}
+interface EnglishConstituentBranch extends EnglishConstituent, ConstituentBranch {
+    @Override
+    EnglishConstituentType type();
+}
+interface EnglishConstituentLeaf extends EnglishConstituent, ConstituentLeaf {
+    @Override
+    EnglishTaggedToken token();
+    @Override
+    default Stream<? extends EnglishConstituent> childStream() {
+        return Stream.empty();
+    }
+}
+interface EnglishDependency extends Dependency {
+    @Override
+    EnglishDependencyType type();
+    @Override
+    EnglishTaggedToken governor();
+    @Override
+    EnglishTaggedToken dependent();
+}
+interface EnglishSentenceSyntax extends SentenceSyntax {
+    @Override
+    EnglishConstituentBranch constituentTree();
+    @Override
+    List<? extends EnglishDependency> dependencies();
+}
+interface EnglishParsedSentence extends EnglishTaggedSentence, ParsedSentence {
+    @Override
+    EnglishSentenceSyntax syntax();
+}
+interface EnglishParsedText extends EnglishTaggedText, ParsedText {
+    @Override // some (or even all) sentences may remain unparsed
+    default Stream<? extends EnglishParsedSentence> parsedSentenceStream() {
+        return Seq.ofType(sentences().stream(), EnglishParsedSentence.class);
+    }
+}
+//
+// 3.B.II) GERMAN
+//
+// 3.B.II.a) GERMAN PARTS OF SPEECH
+interface GermanTaggedToken extends TaggedToken {
+    @Override
+    GermanPartOfSpeech partOfSpeech();
+}
+interface GermanTaggedSentence extends TaggedSentence {
+    @Override
+    List<? extends GermanTaggedToken> tokens();
+}
+interface GermanTaggedText extends TaggedText {
+    @Override
+    default Stream<? extends GermanTaggedSentence> taggedSentenceStream() {
+        return Seq.ofType(sentences().stream(), GermanTaggedSentence.class);
+    }
+}
+// 3.B.II.b) GERMAN SYNTAX (missing as of yet)
 /* ***********************
  * 4) PRODUCERS OF THE API
  *************************/
 interface TextProcessingRequest { // SIMPLIFICATION
     Locale locale();
     String text();
     Stage targetStage();
 }
 interface TextProcessor {
     LocalizedText processText(TextProcessingRequest request);
 }
 /* ***********************
  * 5) CONSUMERS OF THE API
  *************************/
 /*
  * 5.A) DIRECT CONSUMERS
  */
 class GermanPostpositionChecker {
-    void checkTaggedText(TaggedText<GermanPartOfSpeech> text) {
+    void checkTaggedText(GermanTaggedText text) {
         text.taggedSentenceStream().forEach(this::checkTaggedSentence);
     }
-    private void checkTaggedSentence(TaggedSentence<GermanPartOfSpeech> sentence) {
+    private void checkTaggedSentence(GermanTaggedSentence sentence) {
         sentence.tokens().stream()
                 .filter(this::isPostposition)
                 .forEach(this::checkPostposition);
     }
-    private boolean isPostposition(TaggedToken<GermanPartOfSpeech> token) {
+    private boolean isPostposition(GermanTaggedToken token) {
         return token.partOfSpeech().isPostposition();
     }
-    private void checkPostposition(TaggedToken<GermanPartOfSpeech> token) {
+    private void checkPostposition(GermanTaggedToken token) {
         // logic
     }
 }
 class EnglishNominalSubjectChecker {
-    void checkNominalSubjects(ParsedText<?, EnglishDependencyType, EnglishPartOfSpeech> text) {
+    void checkNominalSubjects(EnglishParsedText text) {
         text.parsedSentenceStream().forEach(this::checkNominalSubjects);
     }
-    private void checkNominalSubjects(ParsedSentence<?, EnglishDependencyType, EnglishPartOfSpeech> sentence) {
+    private void checkNominalSubjects(EnglishParsedSentence sentence) {
         sentence.syntax().dependencies().stream()
                 .filter(this::isCertainTypeOfNominalSubjectDependency)
                 .forEach(this::checkNominalSubject);
     }
-    private boolean isCertainTypeOfNominalSubjectDependency(Dependency<EnglishDependencyType, EnglishPartOfSpeech> depen
dency) {
+    private boolean isCertainTypeOfNominalSubjectDependency(EnglishDependency dependency) {
         return dependency.type() == EnglishDependencyType.NOMINAL_SUBJECT && true; // SIMPLIFICATION
     }
-    private void checkNominalSubject(Dependency<EnglishDependencyType, EnglishPartOfSpeech> dependency) {
+    private void checkNominalSubject(EnglishDependency dependency) {
         checkNominalGovernor(dependency.governor());
         checkNominalDependent(dependency.dependent());
     }
-    private void checkNominalGovernor(TaggedToken<EnglishPartOfSpeech> governor) {
+    private void checkNominalGovernor(EnglishTaggedToken governor) {
         if (checkGovernorPartOfSpeech(governor.partOfSpeech())) {
             // logic
         }
     }
-    private void checkNominalDependent(TaggedToken<EnglishPartOfSpeech> dependent) {
+    private void checkNominalDependent(EnglishTaggedToken dependent) {
         if (checkDependentPartOfSpeech(dependent.partOfSpeech())) {
             // logic
         }
     }
     private boolean checkGovernorPartOfSpeech(EnglishPartOfSpeech partOfSpeech) {
         return true; // SIMPLIFICATION
     }
     private boolean checkDependentPartOfSpeech(EnglishPartOfSpeech partOfSpeech) {
         return true; // SIMPLIFICATION
     }
 }
 class EnglishRelevantConstituentHandler {
-    void handleRelevantConstituents(ParsedText<EnglishConstituentType, ?, EnglishPartOfSpeech> text) {
+    void handleRelevantConstituents(EnglishParsedText text) {
         text.parsedSentenceStream().forEach(this::handleRelevantConstiuents);
     }
-    private void handleRelevantConstiuents(ParsedSentence<EnglishConstituentType, ?, EnglishPartOfSpeech> sentence) {
+    private void handleRelevantConstiuents(EnglishParsedSentence sentence) {
-        Constituents.flatConstituentStream(sentence.syntax().constituentTree())
+        EnglishConstituents.flatConstituentStream(sentence.syntax().constituentTree())
                 .filter(this::isRelevantConstituent)
                 .forEach(this::handleRelevantConstituent);
     }
-    private boolean isRelevantConstituent(Constituent<EnglishConstituentType, EnglishPartOfSpeech> constituent) {
+    private boolean isRelevantConstituent(EnglishConstituent constituent) {
         return true; // SIMPLIFICATION
     }
-    private void handleRelevantConstituent(Constituent<EnglishConstituentType, EnglishPartOfSpeech> constituent) {
+    private void handleRelevantConstituent(EnglishConstituent constituent) {
         // logic
     }
 }
-class Constituents {
+class EnglishConstituents {
     /**
      * Returns the constituent and all its descendants as a flattended Stream.
      */
-    static <C extends ConstituentType, P extends PartOfSpeech> Stream<Constituent<C, P>> flatConstituentStream(Constitue
nt<C, P> constituent) {
+    static Stream<EnglishConstituent> flatConstituentStream(EnglishConstituent constituent) {
         return Stream.concat(
                 Stream.of(constituent),
-                constituent.childStream().flatMap(Constituents::flatConstituentStream)
+                constituent.childStream().flatMap(EnglishConstituents::flatConstituentStream)
         );
     }
 }
 /*
  * 5.B) INDIRECT CONSUMERS
  */
 interface ProcessedTextConsumer { // SIMPLIFICATION
     Locale supportedLocale();
     Stage requiredStage();
     void consume(LocalizedText text);
 }
 class SampleUniversalTokenizedTextConsumer implements ProcessedTextConsumer {
     @Override
     public Locale supportedLocale() {
         return Locale.ROOT;
     }
     @Override
     public Stage requiredStage() {
         return Stage.TOKENIZED;
     }
     @Override
     public void consume(LocalizedText text) {
         handleTokenizedText((TokenizedText) text);
     }
     private void handleTokenizedText(TokenizedText tokenizedText) {
         // logic
     }
 }
 class SampleGermanTaggedConsumer implements ProcessedTextConsumer {
     @Override
     public Locale supportedLocale() {
         return Locale.GERMAN;
     }
     @Override
     public Stage requiredStage() {
         return Stage.TAGGED;
     }
     @Override
     public void consume(LocalizedText text) {
-        // UNSAFE UNCHECKED CAST!
+        GermanTaggedText germanTaggedText = (GermanTaggedText) text; // SAFE CAST
-        TaggedText<GermanPartOfSpeech> germanTaggedText = (TaggedText<GermanPartOfSpeech>) text;
         new GermanPostpositionChecker().checkTaggedText(germanTaggedText);
     }
 }
 class SampleEnglishParsedTextConsumer implements ProcessedTextConsumer {
     @Override
     public Locale supportedLocale() {
         return Locale.ENGLISH;
     }
     @Override
     public Stage requiredStage() {
         return Stage.PARSED;
     }
     @Override
     public void consume(LocalizedText text) {
-        // UNSAFE UNCHECKED CAST!
+        EnglishParsedText englishParsedText = (EnglishParsedText) text; // SAFE CAST
-        ParsedText<?, EnglishDependencyType, EnglishPartOfSpeech> englishParsedText
-                = (ParsedText<?, EnglishDependencyType, EnglishPartOfSpeech>) text;
         new EnglishNominalSubjectChecker().checkNominalSubjects(englishParsedText);
     }
 }