Javaにおけるコンビネータパターン：柔軟なコード合成の構築

別名

• 関数合成
• 関数型コンビネータ

コンビネータデザインパターンの目的

コンビネータパターンは、Javaで広く使用されている関数型プログラミングの手法であり、複雑な動作を構築するために関数を組み合わせるために不可欠です。このパターンにより、開発者は複数の小さな関数または操作を単一の、より複雑な操作に組み合わせることができ、柔軟で再利用可能なコードを促進します。高階関数を利用することにより、コンビネータパターンはJavaアプリケーションのコードの再利用性と保守性を向上させ、ソフトウェア設計において貴重なツールとなります。このアプローチは、Java開発におけるモジュール化されたスケーラブルなソリューションの作成を促進します。

現実世界の例を用いたコンビネータパターンの詳細な説明

現実世界の例

現実の世界では、コンビネータデザインパターンはキッチンの食事の準備プロセスに例えることができます。野菜を切る、水を沸かす、ご飯を炊く、鶏肉を焼く、材料を混ぜるといった一連の単純な操作を行うシェフを想像してみてください。これらの操作はそれぞれがスタンドアロンの関数です。シェフはこれらの操作をさまざまな順序で組み合わせて、異なる料理を作ることができます。たとえば、チキンライスボウルを準備するために、シェフはご飯を炊く、鶏肉を焼く、そしてそれらを野菜と混ぜるという操作を組み合わせることができます。これらの基本的な操作を再利用し、さまざまな方法で組み合わせることで、シェフはさまざまな食事を効率的に準備できます。同様に、ソフトウェアでは、コンビネータパターンにより、開発者は単純で再利用可能な関数を組み合わせて、より複雑な動作を作成できます。

分かりやすく言うと

コンビネータデザインパターンは、単純で再利用可能な関数を組み合わせて、より複雑で柔軟な操作を作成します。

Wikipediaによると

コンビネータとは、関数適用と以前に定義されたコンビネータのみを使用して、引数から結果を定義する高階関数です。

Javaにおけるコンビネータパターンのプログラム例

ソフトウェア設計では、コンビネータロジックは、再利用可能でモジュール化されたコードコンポーネントを作成するために不可欠です。高階関数を利用することにより、コンビネータパターンはJavaアプリケーションのコードの再利用性と保守性を向上させます。

このJavaの例では、`contains`、`not`、`or`、`and` などのコンビネータを実装して、複雑なファインダーを作成する方法を示します。

// Functional interface to find lines in text.
public interface Finder {

    // The function to find lines in text.
    List<String> find(String text);

    // Simple implementation of function {@link #find(String)}.
    static Finder contains(String word) {
        return txt -> Stream.of(txt.split("\n"))
                .filter(line -> line.toLowerCase().contains(word.toLowerCase()))
                .collect(Collectors.toList());
    }

    // combinator not.
    default Finder not(Finder notFinder) {
        return txt -> {
            List<String> res = this.find(txt);
            res.removeAll(notFinder.find(txt));
            return res;
        };
    }

    // combinator or.
    default Finder or(Finder orFinder) {
        return txt -> {
            List<String> res = this.find(txt);
            res.addAll(orFinder.find(txt));
            return res;
        };
    }

    // combinator and.
    default Finder and(Finder andFinder) {
        return
                txt -> this
                        .find(txt)
                        .stream()
                        .flatMap(line -> andFinder.find(line).stream())
                        .collect(Collectors.toList());
    }
    // Other properties and methods...
}

さらに、複雑なファインダー `advancedFinder`、`filteredFinder`、`specializedFinder`、`expandedFinder` 用の別のコンビネータもあります。

// Complex finders consisting of simple finder.
public class Finders {

    private Finders() {
    }

    // Finder to find a complex query.
    public static Finder advancedFinder(String query, String orQuery, String notQuery) {
        return
                Finder.contains(query)
                        .or(Finder.contains(orQuery))
                        .not(Finder.contains(notQuery));
    }

    // Filtered finder looking a query with excluded queries as well.
    public static Finder filteredFinder(String query, String... excludeQueries) {
        var finder = Finder.contains(query);

        for (String q : excludeQueries) {
            finder = finder.not(Finder.contains(q));
        }
        return finder;
    }

    // Specialized query. Every next query is looked in previous result.
    public static Finder specializedFinder(String... queries) {
        var finder = identMult();

        for (String query : queries) {
            finder = finder.and(Finder.contains(query));
        }
        return finder;
    }

    // Expanded query. Looking for alternatives.
    public static Finder expandedFinder(String... queries) {
        var finder = identSum();

        for (String query : queries) {
            finder = finder.or(Finder.contains(query));
        }
        return finder;
    }
    // Other properties and methods...
}

コンビネータのインターフェースとメソッドを作成したので、アプリケーションがそれらをどのように使用するかを見てみましょう。

public class CombinatorApp {

    private static final String TEXT = """
            It was many and many a year ago,
            In a kingdom by the sea,
            That a maiden there lived whom you may know
            By the name of ANNABEL LEE;
            And this maiden she lived with no other thought
            Than to love and be loved by me.
            I was a child and she was a child,
            In this kingdom by the sea;
            But we loved with a love that was more than love-
            I and my Annabel Lee;
            With a love that the winged seraphs of heaven
            Coveted her and me.""";

    public static void main(String[] args) {
        var queriesOr = new String[]{"many", "Annabel"};
        var finder = Finders.expandedFinder(queriesOr);
        var res = finder.find(text());
        LOGGER.info("the result of expanded(or) query[{}] is {}", queriesOr, res);

        var queriesAnd = new String[]{"Annabel", "my"};
        finder = Finders.specializedFinder(queriesAnd);
        res = finder.find(text());
        LOGGER.info("the result of specialized(and) query[{}] is {}", queriesAnd, res);

        finder = Finders.advancedFinder("it was", "kingdom", "sea");
        res = finder.find(text());
        LOGGER.info("the result of advanced query is {}", res);

        res = Finders.filteredFinder(" was ", "many", "child").find(text());
        LOGGER.info("the result of filtered query is {}", res);
    }

    private static String text() {
        return TEXT;
    }
}

プログラム出力

20:03:52.746 [main] INFO com.iluwatar.combinator.CombinatorApp -- the result of expanded(or) query[[many, Annabel]] is [It was many and many a year ago,, By the name of ANNABEL LEE;, I and my Annabel Lee;]
20:03:52.749 [main] INFO com.iluwatar.combinator.CombinatorApp -- the result of specialized(and) query[[Annabel, my]] is [I and my Annabel Lee;]
20:03:52.750 [main] INFO com.iluwatar.combinator.CombinatorApp -- the result of advanced query is [It was many and many a year ago,]
20:03:52.750 [main] INFO com.iluwatar.combinator.CombinatorApp -- the result of filtered query is [But we loved with a love that was more than love-]

これで、すべてが `contains`、`or`、`not`、`and` から派生したクエリ検索機能 `expandedFinder`、`specializedFinder`、`advancedFinder`、`filteredFinder` を使用してアプリを設計できます。

Javaでコンビネータパターンを使用する場合

コンビネータパターンは、単純で再利用可能なコンポーネントから複雑な値が構築される関数型プログラミングで特に役立ちます。

適用可能なシナリオには以下が含まれます

• 問題の解決策は、単純で再利用可能なコンポーネントから構築できます。
• 関数の高いモジュール性と再利用性が必要です。
• プログラミング環境は、ファーストクラス関数と高階関数をサポートしています。

Javaにおけるコンビネータパターンの実際の適用例

• HaskellやScalaなどの関数型プログラミング言語は、解析からUI構築まで、さまざまなタスクにコンビネータを広く使用しています。
• ドメイン特化言語、特に解析式文法などの解析に関連するものにおいて。
• JavaScript、Python、Rubyなどの言語の関数型プログラミング用ライブラリにおいて。
• java.util.function.Function#compose
• java.util.function.Function#andThen

コンビネータパターンの利点とトレードオフ

利点

• ドメイン固有の用語を使用することで開発者の生産性を向上させ、Javaアプリケーションの並列実行を促進します。
• 複雑なタスクをより単純で構成可能な関数に分解することにより、モジュール性と再利用性を向上させます。
• 宣言型のプログラミングスタイルを使用することで、可読性と保守性を向上させます。
• 関数合成による遅延評価と、潜在的により効率的な実行を促進します。

トレードオフ

• 関数型プログラミングの原則に慣れていない人にとっては、学習曲線が急になる可能性があります。
• 中間関数の作成により、パフォーマンスのオーバーヘッドが発生する可能性があります。
• 関数合成の抽象的な性質のため、デバッグが難しい場合があります。

関連するJavaデザインパターン

• 責任連鎖：オブジェクトの連鎖に依存しますが、コンビネータは関数を連鎖させます。
• デコレータ：機能強化においてコンビネータに似ていますが、デコレータはオブジェクトの拡張に焦点を当てています。
• ストラテジー：どちらも実行時にアルゴリズムを選択しますが、コンビネータは関数の合成を使用します。

参考文献とクレジット

• Scalaの関数型プログラミング
• Haskell：関数型プログラミングの技巧
• コンピュータプログラムの構造と解釈
• Java 8を使用したコンビネータパターン (Gregor Trefs)