Wikibooks

プログラミング/関数合成

< プログラミング

関数合成とは

編集

関数合成（Function Composition）は、複数の関数を組み合わせて新しい関数を作成する数学的かつプログラミング的な技法です。本質的には、ある関数の出力を別の関数の入力として使用することを意味します。

関数合成の主な特徴

編集
  • 関数の連鎖：複数の関数を順次適用
  • 宣言的プログラミング：処理の手順よりも変換の連鎖に焦点
  • コードの再利用性向上
  • 関数型プログラミングの基本的な概念

関数合成の基本的な実装

編集

JavaScript

編集 
// 基本的な関数合成
const compose = (f, g) => x => f(g(x));

// 具体的な例
const double = x => x * 2;
const increment = x => x + 1;

const doubleAndIncrement = compose(increment, double);
console.log(doubleAndIncrement(5));  // 11

// 複数関数の合成
const composeMultiple = (...functions) => 
    functions.reduce((f, g) => (...args) => f(g(...args)));

const addTen = x => x + 10;
const square = x => x * x;
const complexOperation = composeMultiple(addTen, square, increment);
console.log(complexOperation(3));  // (3 + 1)² + 10 = 100

Haskell

編集 
-- 関数合成演算子
(.) :: (b -> c) -> (a -> b) -> (a -> c)
f . g = \x -> f (g x)

-- 具体的な例
double :: Int -> Int
double x = x * 2

increment :: Int -> Int
increment x = x + 1

-- 関数合成の使用
composedFunction = increment . double
result = composedFunction 5  -- 11

Scala

編集 
object FunctionComposition {
    // 明示的な関数合成
    def compose[A, B, C](f: B => C, g: A => B): A => C = 
        x => f(g(x))

    // 具体的な例
    def double(x: Int): Int = x * 2
    def increment(x: Int): Int = x + 1

    def main(args: Array[String]): Unit = {
        val doubleAndIncrement = compose(increment, double)
        println(doubleAndIncrement(5))  // 11

        // パイプライン演算子による関数合成
        val result = 5
            .pipe(double)
            .pipe(increment)
        println(result)  // 11
    }
}

Rust

編集 
fn compose<F, G, A, B, C>(f: F, g: G) -> impl Fn(A) -> C
where
    F: Fn(B) -> C,
    G: Fn(A) -> B,
{
    move |x| f(g(x))
}

fn main() {
    let double = |x| x * 2;
    let increment = |x| x + 1;

    let double_and_increment = compose(increment, double);
    println!("{}", double_and_increment(5));  // 11
}

関数合成の実践的な利用

編集

データ変換パイプライン

編集

TypeScript

編集 
type Transformer<T, U> = (input: T) => U;

class DataPipeline<T> {
    private value: T;

    constructor(initialValue: T) {
        this.value = initialValue;
    }

    pipe<U>(transformer: Transformer<T, U>): DataPipeline<U> {
        return new DataPipeline(transformer(this.value));
    }

    get(): T {
        return this.value;
    }
}

// 具体的な変換関数
const sanitizeString = (s: string) => s.trim().toLowerCase();
const capitalizeFirstLetter = (s: string) => 
    s.charAt(0).toUpperCase() + s.slice(1);

const processName = new DataPipeline("  JOHN doe  ")
    .pipe(sanitizeString)
    .pipe(capitalizeFirstLetter)
    .get();

console.log(processName);  // "John doe"

ロギングとデバッグ

編集

Kotlin

編集 
class Debugger {
    fun <T, R> trace(transform: (T) -> R): (T) -> R {
        return { input ->
            println("Input: $input")
            val result = transform(input)
            println("Output: $result")
            result
        }
    }
}

fun main() {
    val debugger = Debugger()
    
    val double: (Int) -> Int = { it * 2 }
    val increment: (Int) -> Int = { it + 1 }
    
    val tracedComposition = debugger.trace(increment).compose(double)
    tracedComposition(5)
}

バリデーションチェーン

編集

Swift

編集 
struct Validator {
    static func compose<T>(_ validators: [(T) -> Bool]...) -> (T) -> Bool {
        return { input in
            validators.allSatisfy { validator in
                validator(input)
            }
        }
    }
}

func main() {
    let isPositive: (Int) -> Bool = { $0 > 0 }
    let isEven: (Int) -> Bool = { $0 % 2 == 0 }
    
    let combinedValidator = Validator.compose(isPositive, isEven)
    
    print(combinedValidator(6))   // true
    print(combinedValidator(5))   // false
    print(combinedValidator(-2))  // false
}

高度な関数合成テクニック

編集

アスペクト指向プログラミング

編集

Go

編集 
type Middleware func(HandlerFunc) HandlerFunc
type HandlerFunc func(int) int

func withLogging(next HandlerFunc) HandlerFunc {
    return func(x int) int {
        fmt.Printf("Input: %d\n", x)
        result := next(x)
        fmt.Printf("Output: %d\n", result)
        return result
    }
}

func withErrorHandling(next HandlerFunc) HandlerFunc {
    return func(x int) int {
        if x < 0 {
            return 0
        }
        return next(x)
    }
}

func compose(middlewares ...Middleware) Middleware {
    return func(final HandlerFunc) HandlerFunc {
        for i := len(middlewares) - 1; i >= 0; i-- {
            final = middlewares[i](final)
        }
        return final
    }
}

モナディックな関数合成

編集

OCaml

編集 
module Option = struct
  let bind m f = match m with
    | Some x -> f x
    | None -> None

  let (>>=) = bind

  let return x = Some x
end

(* オプション型での関数合成 *)
let safe_divide a b =
  if b = 0 then None else Some (a / b)

let safe_increment x = 
  Some (x + 1)

let complex_operation x = 
  safe_divide x 2 >>= safe_increment

関数合成のパターン

編集

左から右への合成

編集
  • パイプライン演算子（`|>`）
  • データの変換を明確に表現
  • 読みやすいコード構造

右から左への合成

編集
  • 数学的な関数合成の伝統的な方法
  • 関数適用の順序を明示的に制御

関数合成の利点と注意点

編集

利点

編集
  • コードの modularity 向上
  • 宣言的なプログラミングスタイル
  • 関数の再利用性
  • テストと保守の容易さ

注意点

編集
  • パフォーマンスのオーバーヘッド
  • 過度な抽象化の回避
  • 可読性とのバランス

まとめ

編集

関数合成は、関数型プログラミングにおける最も強力で優雅な技法の一つです。複雑な処理を単純で再利用可能な関数の組み合わせに分解することを可能にします。

"https://ja.wikibooks.org/w/index.php?title=プログラミング/関数合成&oldid=264250" より作成