PerlのList::AllUtilsの逆引きを作った で検証したテストコード

test.pl

use strict;
use warnings;
use utf8;

use Test2::V0 -srand => 1234;
use List::AllUtils qw(:all);

subtest '条件を満たす最初の要素をとる' => sub {
    subtest 'case: first' => sub {
        my @list = (4, 7, 1);
        my $result = first { $_ > 5 } @list;
        is $result, 7;
    };

    subtest 'case: first_value' => sub {
        my @list = (4, 7, 1);
        my $result = first_value { $_ > 5 } @list;
        is $result, 7;
    };

    subtest 'case: firstval' => sub {
        my @list = (4, 7, 1);
        my $result = firstval { $_ > 5 } @list;
        is $result, 7;
    };

    subtest 'case: extract_first_by' => sub {
        my @list = (4, 7, 1);
        my $result = extract_first_by { $_ > 5 } @list; # 7
        is $result, 7;
        is \@list, [4, 1];
    };

    subtest 'case: reduce' => sub {
        my @list = (4, 7, 1);
        my $result = reduce {
            defined($a)            ? $a :
            $b > 5                 ? $b :
                                     undef
        } undef, @list;
        is $result, 7;
    };
};

subtest '条件を満たす最後の要素をとる' => sub {
    subtest 'last_value' => sub {
        my @list = (4, 7, 1);
        my $result = last_value { $_ < 5 } @list;
        is $result, 1;
    };

    subtest 'lastval' => sub {
        my @list = (4, 7, 1);
        my $result = lastval { $_ < 5 } @list;
        is $result, 1;
    };
};

subtest '条件を満たす要素より後ろの要素たちを抽出する' => sub {
    my @list = (2, 4, 6, 8, 10);
    my @result = after { $_ > 5 } @list; # (8, 10)
    is \@result, [8, 10];
};

subtest '条件を満たす要素以降の要素たちを抽出する' => sub {
    my @list = (2, 4, 6, 8, 10);
    my @result = after_incl { $_ > 5 } @list; # (6, 8, 10)
    is \@result, [6, 8, 10];
};

subtest '条件を満たす要素より前の要素たちを抽出する' => sub {
    my @list = (2, 4, 6, 8, 10);
    my @result = before { $_ > 5 } @list; # (2, 4)
    is \@result, [2, 4];
};

subtest '条件を満たす要素以前の要素たちを抽出する' => sub {
    my @list = (2, 4, 6, 8, 10);
    my @result = before_incl { $_ > 5 } @list; # (2, 4, 6)
    is \@result, [2, 4, 6];
};

subtest '先頭からいくつかの要素を抽出する' => sub {
    my @list = 1..10;
    my @result = head 3, @list; # (1, 2, 3)
    is \@result, [1, 2, 3];

    my @result_minus = head -2, @list; # (1, 2, 3, 4, 5, 6, 7, 8)
    is \@result_minus, [1, 2, 3, 4, 5, 6, 7, 8];
};

subtest '末尾からいくつかの要素を抽出する' => sub {
    my @list = 1..10;
    my @result = tail 3, @list; # (8, 9, 10)
    is \@result, [8, 9, 10];

    my @result_minus = tail -2, @list; # (3, 4, 5, 6, 7, 8, 9, 10)
    is \@result_minus, [3, 4, 5, 6, 7, 8, 9, 10];
};

subtest '1つしかない要素のみを抽出する' => sub {
    my @list = (1, 1, 1, 2, 3, 3, 4, 5);
    my @result = singleton @list; # (2, 4, 5)
    is \@result, [2, 4, 5];
};

subtest '要素を検索する' => sub {
    subtest '組み込み関数のgrep' => sub {
        my @list = 1...10;
        my @result = grep { $_ == 4 } @list;
        is \@result, [4];
    };

    subtest 'bsearch' => sub {
        my @sorted_list = 1...10;
        my @result = bsearch { $_ <=> 4 } @sorted_list;
        is \@result, [4];
    };

    subtest 'extract_by' => sub {
        my @list = 1...10;
        my @result = extract_by { $_ == 4 } @list; # (4)
        is \@result, [4];
        is \@list, [1, 2, 3, 5, 6, 7, 8, 9, 10];
    };
};

subtest '条件を満たす要素数を求める' => sub {
    my @list = 1...10;
    my $result = true { $_ < 4 } @list; # 3
    is $result, 3;
};

subtest '条件を満たさない要素数を求める' => sub {
    my @list = 1...10;
    my $result = false { $_ < 4 } @list; # 7
    is $result, 7;
};

subtest '検索した要素のインデックスを求める' => sub {
    subtest 'bsearch_index' => sub {
        my @sorted_list = 1...10;

        subtest 'bsearch_index' => sub {
            my $result = bsearch_index { $_ <=> 4 } @sorted_list; # 3
            is $result, 3;
        };

        subtest 'bsearchidx' => sub {
            my $result = bsearchidx { $_ <=> 4 } @sorted_list; # 同じ(bsearch_indexのエイリアス)
            is $result, 3;
        };
    };

    subtest 'indexes' => sub {
        my @list = (1, 1, 1, 2, 4, 1);
        my @result = indexes { $_ == 1 } @list; # (1, 2, 3, 6)
        is \@result, [0, 1, 2, 5];
    };
};

subtest '条件を満たす最初の要素のインデックスを求める' => sub {
    my @list = (1, 1, 1, 2, 4, 1);

    subtest 'first_index' => sub {
        my $result = first_index { $_ == 1 } @list; # 0
        is $result, 0;
    };

    subtest 'firstidx' => sub {
        my $result = firstidx { $_ == 1 } @list; # 同じ(first_indexのエイリアス)
        is $result, 0;
    };
};

subtest '条件を満たす最後の要素のインデックスを求める' => sub {
    my @list = (1, 1, 1, 2, 4, 1);

    subtest 'last_index' => sub {
        my $result = last_index { $_ == 1 } @list; # 6
        is $result, 5;
    };

    subtest 'lastidx' => sub {
        my $result = lastidx { $_ == 1 } @list; # 同じ(last_indexのエイリアス)
        is $result, 5;
    };
};

subtest '条件を満たすただ一つの要素のインデックスを求める' => sub {
    my @list = (1, 1, 1, 2, 4, 1);

    subtest 'only_index' => sub {
        subtest 'only element' => sub {
            my $result = only_index { $_ == 2 } @list; # 3
            is $result, 3;
        };
        subtest 'not only element' => sub {
            my $result = only_index { $_ == 1 } @list; # -1
            is $result, -1;
        };
    };

    subtest 'onlyidx' => sub {
        my $result_b = onlyidx { $_ == 2 } @list; # 同じ(only_indexのエイリアス)
        is $result_b, 3;
    };
};

subtest '最初にCODE BLOCKが正常終了する要素の結果を求める' => sub {
    my @list = (4, 7, 1);

    subtest 'first_result' => sub {
        my $result = first_result { $_ ** 2 if $_ > 3 } @list; # 16
        is $result, 16;
    };

    subtest 'firstres' => sub {
        my $result = firstres { $_ ** 2 if $_ > 3 } @list; # 同じ(first_indexのエイリアス)
        is $result, 16;
    };
};

subtest '最後にCODE BLOCKが正常終了する要素の結果を求める' => sub {
    my @list = (4, 7, 1);

    subtest 'last_result' => sub {
        my $result = last_result { $_ ** 2 if $_ > 3 } @list; # 49
        is $result, 49;
    };

    subtest 'lastres' => sub {
        my $result = lastres { $_ ** 2 if $_ > 3 } @list; # 同じ(last_indexのエイリアス)
        is $result, 49;
    };
};

subtest '一つだけCODE BLOCKが正常終了する要素の結果を求める' => sub {
    my @list = (4, 7, 1);

    subtest 'only_result' => sub {
        subtest 'only element' => sub {
            my $result = only_result { $_ ** 2 if $_ > 5 } @list; # 49
            is $result, 49;
        };
        subtest 'not only element' => sub {
            my $result = onlyres { $_ ** 2 if $_ > 3 } @list; # undef
            is $result, undef;
        };
    };

    subtest 'onlyidx' => sub {
        my $result_b = onlyres { $_ ** 2 if $_ > 5 } @list; # 同じ(only_indexのエイリアス)
        is $result_b, 49;
    };
};

subtest '要素の最大値を求める' => sub {
    subtest 'max' => sub {
        my @list = (1, 4, 3);
        my $result = max @list; # 4
        is $result, 4;
    };

    subtest 'max_by' => sub {
        my @list = ({ value => 2, id => 1 }, { value => 5, id => 2 }, { value => 5, id => 3 });
        my $result = max_by { $_->{value} } @list; # { value => 5, id => 2 }
        is $result, { value => 5, id => 2 };

        my @result_b = max_by { $_->{value} } @list; # ({ value => 5, id => 2 }, { value => 5, id => 3})
        is \@result_b, [{ value => 5, id => 2 }, { value => 5, id => 3}];
    };
};

subtest '文字列の最大を求める' => sub {
    subtest 'maxstr' => sub {
        my @list = qw/a b c/;
        my $result = maxstr @list; # c
        is $result, 'c';
    };

    subtest 'reduce' => sub {
        my @list = ({ name => 'a' }, { name => 'b' }, {name => 'c' });
        my $result = reduce { $a->{name} gt $b->{name} ? $a : $b } @list; # { name => 'c' }
        is $result, { name => 'c' };
    };
};

subtest '要素の最小値を求める' => sub {
    subtest 'maxstr' => sub {
        my @list = (2, 3, 1);
        my $result = min @list; # 1
        is $result, 1
    };

    subtest 'min_by' => sub {
        my @list = ({ value => 2, id => 1 }, { value => 1, id => 2 }, { value => 1, id => 3 });
        my $result = min_by { $_->{value} } @list; # { value => 1, id => 2 }
        is $result, { value => 1, id => 2 };

        my @result_b = min_by { $_->{value} } @list; # ({ value => 1, id => 2 }, { value => 1, id => 3})
        is \@result_b, [{ value => 1, id => 2 }, { value => 1, id => 3}];
    };
};

subtest '文字列の最小を求める' => sub {
    subtest 'minstr' => sub {
        my @list = qw/b c a/;
        my $result = minstr @list; # a
        is $result, 'a';
    };

    subtest 'reduce' => sub {
        my @list = ({ name => 'b' }, { name => 'a' }, {name => 'c' });
        my $result = reduce { $a->{name} lt $b->{name} ? $a : $b } @list; # { name => 'a' }
        is $result, { name => 'a' };
    };
};

subtest '最小値と最大値を同時に求める' => sub {
    subtest 'minmax' => sub {
        my @list = (2, 3, 1);
        my ($min, $max) = minmax @list; # (1, 3)

        is $min, 1;
        is $max, 3;
    };

    subtest 'minmax_by' => sub {
        my @list = ({ value => 2, id => 1 }, { value => 1, id => 2 }, { value => 1, id => 3 });
        my ($min, $max) = minmax_by { $_->{value} } @list; # ({ value => 1, id => 2 }, { value => 2, id => 1 })

        is $min, { value => 1, id => 2 };
        is $max, { value => 2, id => 1 };
    };
};

subtest 'リストを文字列順で並べ変える' => sub {
    subtest '組み込み関数のsort' => sub {
        my @list = ('banana', 'melon', 'apple');
        my @result = sort @list; # ('apple', 'banana', 'melon')
        is \@result, ['apple', 'banana', 'melon'];
    };

    subtest 'sort_by' => sub {
        my @list = ({ name => 'banana' }, { name => 'melon' }, { name => 'apple' });
        my @result = sort_by { $_->{name} } @list; # ({ name => 'apple' }, { name => 'banana' }, { name => 'melon' })
        is \@result, [{ name => 'apple' }, { name => 'banana' }, { name => 'melon' }];
    };

    subtest 'rev_sort_by' => sub {
        my @list = ({ name => 'banana' }, { name => 'melon' }, { name => 'apple' });
        my @result = rev_sort_by { $_->{name} } @list; # ({ name => 'melon' }, { name => 'banana' }, { name => 'apple' })
        is \@result, [{ name => 'melon' }, { name => 'banana' }, { name => 'apple' }];
    };
};

subtest 'リストを数値順で並べ変える' => sub {
    subtest '組み込み関数のsort' => sub {
        my @list = (23, 1, 12);
        my @result = sort { $a <=> $b } @list; # (1, 12, 23)
        is \@result, [1, 12, 23];
    };

    subtest 'nsort_by' => sub {
        my @list = ({ value => 23 }, { value => 1 }, { value => 12 });
        my @result = nsort_by { $_->{value} } @list; # ({ value => 1 }, { value => 12 }, { value => 23 })
        is \@result, [{ value => 1 }, { value => 12 }, { value => 23 }];
    };

    subtest 'rev_nsort_by' => sub {
        my @list = ({ value => 23 }, { value => 1 }, { value => 12 });
        my @result = rev_nsort_by { $_->{value} } @list; # ({ value => 23 }, { value => 12 }, { value => 1 })
        is \@result, [{ value => 23 }, { value => 12 }, { value => 1 }];
    };
};

subtest '文字列を結合する' => sub {
    subtest 'join' => sub {
        my @list = qw/a b c/;
        my $result = join '', @list; # "abc"
        is $result, 'abc';
    };

    subtest 'reduce' => sub {
        my @list = qw/a b c/;
        my $result = reduce { uc($a) . uc($b) } @list; # "ABC"
        is $result, 'ABC';
    };
};

subtest '要素の合計を求める' => sub {
    subtest 'sum' => sub {
        subtest '1..10' => sub {
            my @list = 1..10;
            my $result = sum @list; # 55
            is $result, 55;
        };

        subtest 'empty list' => sub {
            # 要素がない時はundefを返す
            my @list = ();
            my $result = sum @list; # undef
            is $result, undef;
        };
    };

    subtest 'sum0' => sub {
        my @list = ();
        my $result = sum0 @list; # 0
        is $result, 0;
    };

    subtest 'reduce' => sub {
        my @list = ({ value => 2 }, { value => 4 }, { value => 1 });
        my $result = reduce { $a + $b->{value} } 0, @list; # 7
        is $result, 7;
   };
};

subtest '要素の積を求める' => sub {
    subtest 'product' => sub {
        subtest '1..10' => sub {
            my @list = 1..10;
            my $result = product @list; # 3628800
            is $result, 3628800;
        };

        subtest 'empty list' => sub {
            # 要素がない時は1を返す
            my @list = ();
            my $result = product @list; # 1
            is $result, 1;
        };
    };

    subtest 'reduce' => sub {
        my @list = ({ value => 2 }, { value => 4 }, { value => 1 });
        my $result = reduce { $a * $b->{value} } 1, @list; # 8
        is $result, 8;
   };
};

subtest '各要素のうちどれかが条件を満たすならtrue' => sub {
    subtest 'any' => sub {
        subtest 'some list' => sub {
            my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
            my $result = any { $_->{flag} } @list; # 1
            is $result, 1;
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = any { $_->{flag} } @list; # ""
            is $result, "";
        };
    };

    subtest 'any_u' => sub {
        subtest 'some list' => sub {
            my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
            my $result = any_u { $_->{flag} } @list; # 1
            is $result, 1;
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = any_u { $_->{flag} } @list; # undef
            is $result, undef;
        };
    };
};

subtest '各要素のうちどれかが条件を満たさないならtrue' => sub {
    subtest 'notall' => sub {
        subtest 'some list' => sub {
            my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
            my $result = notall { $_->{flag} } @list; # 1
            is $result, 1;
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = notall { $_->{flag} } @list; # ""
            is $result, "";
        };
    };

    subtest 'notall_u' => sub {
        subtest 'some list' => sub {
            my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
            my $result = notall_u { $_->{flag} } @list; # 1
            is $result, 1;
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = notall_u { $_->{flag} } @list; # undef
            is $result, undef;
        };
    };
};

subtest '全要素が条件を満たすならtrue' => sub {
    subtest 'all' => sub {
        subtest 'some list' => sub {
            subtest 'true' => sub {
                my @list = ({ flag => 1 }, { flag => 1 }, { flag => 1 });
                my $result = all { $_->{flag} } @list; # 1
                is $result, 1;
            };

            subtest 'false' => sub {
                my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
                my $result = all { $_->{flag} } @list; # ""
                is $result, "";
            };
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = all { $_->{flag} } @list; # 1
            is $result, 1;
        };
    };

    subtest 'all_u' => sub {
        subtest 'some list' => sub {
            subtest 'true' => sub {
                my @list = ({ flag => 1 }, { flag => 1 }, { flag => 1 });
                my $result = all_u { $_->{flag} } @list; # 1
                is $result, 1;
            };

            subtest 'false' => sub {
                my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
                my $result = all_u { $_->{flag} } @list; # ""
                is $result, "";
            };
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = all_u { $_->{flag} } @list; # undef
            is $result, undef;
        };
    };
};

subtest '全要素が条件を満たさないならtrue' => sub {
    subtest 'none' => sub {
        subtest 'some list' => sub {
            subtest 'true' => sub {
                my @list = ({ flag => 0 }, { flag => 0 }, { flag => 0 });
                my $result = none { $_->{flag} } @list; # 1
                is $result, 1;
            };

            subtest 'false' => sub {
                my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
                my $result = none { $_->{flag} } @list; # ""
                is $result, "";
            };
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = none { $_->{flag} } @list; # 1
            is $result, 1;
        };
    };

    subtest 'none_u' => sub {
        subtest 'some list' => sub {
            subtest 'true' => sub {
                my @list = ({ flag => 0 }, { flag => 0 }, { flag => 0 });
                my $result = none_u { $_->{flag} } @list; # 1
                is $result, 1;
            };

            subtest 'false' => sub {
                my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
                my $result = none_u { $_->{flag} } @list; # ""
                is $result, "";
            };
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = none_u { $_->{flag} } @list; # undef
            is $result, undef;
        };
    };
};

subtest '要素がただ1つだけ条件を満たすならtrue' => sub {
    subtest 'one' => sub {
        subtest 'some list' => sub {
            subtest 'true' => sub {
                my @list = ({ flag => 0 }, { flag => 1 }, { flag => 0 });
                my $result = one { $_->{flag} } @list; # 1
                is $result, 1;
            };

            subtest 'false' => sub {
                my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
                my $result = one { $_->{flag} } @list; # ""
                is $result, "";
            };
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = one { $_->{flag} } @list; # ""
            is $result, "";
        };
    };

    subtest 'one_u' => sub {
        subtest 'some list' => sub {
            subtest 'true' => sub {
                my @list = ({ flag => 0 }, { flag => 1 }, { flag => 0 });
                my $result = one_u { $_->{flag} } @list; # 1
                is $result, 1;
            };

            subtest 'false' => sub {
                my @list = ({ flag => 1 }, { flag => 0 }, { flag => 1 });
                my $result = one_u { $_->{flag} } @list; # ""
                is $result, "";
            };
        };

        subtest 'empty list' => sub {
            my @list = ();
            my $result = one_u { $_->{flag} } @list; # undef
            is $result, undef;
        };
    };
};

subtest 'それぞれの要素に処理を行いたい' => sub {
    subtest '組み込み関数のmap' => sub {
        my @list = (4, 7, 1);
        my @result = map { $_ *= 2 } @list; # (8, 14, 2)
        is \@result, [8, 14, 2];
        is \@list, [8, 14, 2];
    };

    subtest 'apply' => sub {
        my @list = (4, 7, 1);
        my @result = apply { $_ *= 2 } @list; # (8, 14, 2)
        is \@result, [8, 14, 2];
        is \@list, [4, 7, 1];
    };

    subtest 'bundle_by' => sub {
        my @list = (1...8);
        my @result = bundle_by { [$_[0], $_[1], $_[2]] } 3, @list; # ([1, 2, 3], [4, 5, 6], [7, 8, undef])
        is \@result, [[1, 2, 3], [4, 5, 6], [7, 8, undef]];
    };
};

subtest 'シャッフル' => sub {
    local $List::Util::RAND = sub { 1234 };

    subtest 'shuffle' => sub {
        note '環境によっては結果が変わるかも';
        my @list = ('a', 'b', 'c', 'd');
        my @result = shuffle @list;
        is \@result, ['c', 'b', 'a', 'd'];
    };
};

subtest '重み付けされたシャッフル' => sub {
    subtest 'weighted_shuffle_by' => sub {
        note '環境によっては結果が変わるかも';
        my @list = ('a', 'b', 'c');
        my @result = weighted_shuffle_by { { a => 1, b => 0, c => 99 }->{$_} } @list;
        is \@result, ['c', 'a', 'b'];
    };
};

subtest '最頻値を求める' => sub {
    my @list = ('apple', 'pineapple', 'apple', 'banana', 'apple', 'apple', 'apple');
    my @result = mode @list; # ('apple')
    is $result[0], 'apple';
};

subtest '重複を弾く' => sub {
    subtest 'uniq' => sub {
        my @list = ('hoge', 'hoge', 22, 35, 10, 22);
        my @result = uniq @list; # ('hoge', 22, 35, 10)
        is \@result, ['hoge', 22, 35, 10];
    };

    subtest 'distinct' => sub {
        my @list = ('hoge', 'hoge', 22, 35, 10, 22);
        my @result_d = distinct @list; # 同じ(uniqのエイリアス)
        is \@result_d, ['hoge', 22, 35, 10];
    };

    subtest 'uniqnum' => sub {
        my @list = (1, 2, 3, 1, 5);
        my @result = uniqnum @list; # (1, 2, 3, 5)
        is \@result, [1, 2, 3, 5];
    };

    subtest 'uniqstr' => sub {
        my @list = ('a', 'A', 'aa', 'a');
        my @result = uniqstr @list; # ('a', 'A', 'aa')
        is \@result, ['a', 'A', 'aa'];
    };

    subtest 'uniq_by' => sub {
        my @list = ({ value => 2, id => 1 }, { value => 1, id => 2 }, { value => 1, id => 3 });
        my @result = uniq_by { $_->{value} } @list; # ({ value => 2, id => 1 }, { value => 1, id => 2 })
        is \@result, [{ value => 2, id => 1 }, { value => 1, id => 2 }];
    };
};

subtest '特定の要素の後ろに要素を追加する' => sub {
    subtest 'insert_after' => sub {
        my @list = (1, 2, 3, 5);
        my $result = insert_after { $_ == 3 } 4, @list;
        is $result, 1;
        is \@list, [1, 2, 3, 4, 5];
    };

    subtest 'insert_after_string' => sub {
        my @list = ('first', 'second', 'third', 'fifth');
        my $result = insert_after_string 'third', 'fourth', @list;
        is $result, 1;
        is \@list, ['first', 'second', 'third', 'fourth', 'fifth'];
    };
};

subtest '2つのリストを同時に操作する' => sub {
    my @list_a = ('a', 'b', 'c');
    my @list_b = (1, 2, 3);
    my @result = pairwise { { str => $a, num => $b } } @list_a, @list_b;
    is \@result, [ { str => 'a', num => 1 }, { str => 'b', num => 2 }, { str => 'c', num => 3 } ];
};

subtest '複数のリストを1つのリストにする' => sub {
    my @list_a = ('a', 'b', 'c');
    my @list_b = (1, 2);

    subtest 'mesh' => sub {
        my @result = mesh @list_a, @list_b; # ('a', 1, 'b', 2, 'c', undef);
        is \@result, ['a', 1, 'b', 2, 'c', undef];
    };

    subtest 'zip' => sub {
        my @result = zip @list_a, @list_b; # 同じ(meshのエイリアス)
        is \@result, ['a', 1, 'b', 2, 'c', undef];
    };

    subtest 'zip_by' => sub {
        my @list_a = ('a', 'b', 'c');
        my @list_b = (1, 2);
        my @result = zip_by { $_[0], $_[1] } \@list_a, \@list_b; # ('a', 1, 'b', 2, 'c', undef)
        is \@result, ['a', 1, 'b', 2, 'c', undef];
    };
};

subtest '1つのリストを複数のリストに仕分ける' => sub {
    subtest 'part' => sub {
        my @list = (1, 2, 1, 1, 2);
        my @result = part { $_ } @list; # ( undef, [1, 1, 1], [2, 2] )
        is \@result, [undef, [1, 1, 1], [2, 2]];
    };

    subtest 'partition_by' => sub {
        my @list = (1, 2, 1, 1, 2);
        my %result = partition_by { $_ } @list; # ( undef, [1, 1, 1], [2, 2] )
        is \%result, { 1 => [ 1, 1, 1 ], 2 => [ 2, 2] };
    };
};

subtest '各要素を複数のリストに仕分ける' => sub {
    my @list = ({id => 1, name => 'hoge', }, {id => 2, name => 'fuga'}, {id => 3, name => 'piyo'});
    my ($ids, $names) = unzip_by { $_->{id}, $_->{name} } @list; # ids: (1, 2, 3), names: ('hoge', 'fuga', 'piyo')
    is $ids, [1, 2, 3];
    is $names, ['hoge', 'fuga', 'piyo'];
};

subtest '条件ごとの要素数を求める' => sub {
    my @list = (1, 2, 1, 1, 2);
    my %result = count_by { $_ } @list; # { 1 => 3, 2 => 2 }
    is \%result, { 1 => 3, 2 => 2 };
};

subtest 'リストからイテレータを作成する' => sub {
    subtest 'each_array' => sub {
        my @list = (1, 2, 3);
        my $result = each_array(@list);

        is $result->(), 1;
        is $result->(), 2;
        is $result->(), 3;
        is $result->(), undef;
    };

    subtest 'each_arrayref' => sub {
        my $list = [1, 2, 3];
        my $result = each_arrayref($list);

        is $result->(), 1;
        is $result->(), 2;
        is $result->(), 3;
        is $result->(), undef;
    };
};

subtest 'リストから複数まとめて返すイテレータを作成する' => sub {
    my @list = (1...8);
    my $result = natatime 3, @list;

    is [ $result->() ], [1,2,3]; # (1, 2, 3)
    is [ $result->() ], [4,5,6]; # (4, 5, 6)
    is [ $result->() ], [7,8]; # (7, 8)
    is   $result->(),   undef; # undef
};


subtest 'key-valueリストをまとめて1要素にする' => sub {
    my @list = ('k1', 'v1', 'k2', 'v2');
    my @result = pairs @list; # ( ['k1', 'v1'], ['k2', 'v2'] )
    is \@result, [ ['k1', 'v1'], ['k2', 'v2'] ];
};

subtest 'key, valueのまとまりを展開する' => sub {
    my @list = ( ['k1', 'v1'], ['k2', 'v2'] );
    my @result = unpairs @list; # ('k1', 'v1', 'k2', 'v2')
    is \@result, ['k1', 'v1', 'k2', 'v2']
};

subtest 'key-valueリストのkeyのみを抽出する' => sub {
    my @list = ('k1', 'v1', 'k2', 'v2');
    my @result = pairkeys @list; # ( 'k1', 'k2' )
    is \@result, ['k1', 'k2'];
};

subtest 'key-valueリストのvalueのみを抽出する' => sub {
    my @list = ('k1', 'v1', 'k2', 'v2');
    my @result = pairvalues @list; # ( 'v1', 'v2' )
    is \@result, ['v1', 'v2'];
};

subtest 'key-valueリストから条件にあう全要素を抽出する' => sub {
    my @list = ('k1', 'v1', 'k2', 'v2', 'k3', 'v1');
    my @result = pairgrep { $b eq 'v1' } @list; # ('k1', 'v1', 'k3', 'v1')
    is \@result, ['k1', 'v1', 'k3', 'v1'];

    my $result = pairgrep { $a eq 'k1' && $b eq 'v1' } @list; # 1
    is $result, 1;
};

subtest '条件にあう最初の要素を抽出する' => sub {
    my @list = ('k1', 'v1', 'k2', 'v2', 'k3', 'v1');
    my ($key, $value) = pairfirst { $b eq 'v1' } @list; # $key = 'k1', $value = 'v1'
    is $key, 'k1',
    is $value, 'v1',
};

subtest '条件にあう要素が見つかったかを調べる' => sub {
    my @list = ('k1', 'v1', 'k2', 'v2', 'k3', 'v1');

    my $result = pairfirst { $b eq 'v1' } @list; # 1
    is $result, 1;
};

subtest 'key-valueリストにmapと同じことをしたい' => sub {
    my @list = ('k1', 'v1', 'k2', 'v2');
    my @result = pairmap { "$a-$b" } @list; # ( 'k1-v1', 'k2-v2' )
    is \@result, ['k1-v1', 'k2-v2']
};

done_testing;