NAME
    Bencher::Scenario::SetOperationModules - Benchmark Perl set operation
    (union, intersection, diff, symmetric diff) modules

VERSION
    This document describes version 0.130 of
    Bencher::Scenario::SetOperationModules (from Perl distribution
    Bencher-Scenario-SetOperationModules), released on 2021-05-15.

SYNOPSIS
    To run benchmark with default option:

     % bencher -m SetOperationModules

    To run module startup overhead benchmark:

     % bencher --module-startup -m SetOperationModules

    For more options (dump scenario, list/include/exclude/add participants,
    list/include/exclude/add datasets, etc), see bencher or run "bencher
    --help".

DESCRIPTION
    Packaging a benchmark script as a Bencher scenario makes it convenient
    to include/exclude/add participants/datasets (either via CLI or Perl
    code), send the result to a central repository, among others . See
    Bencher and bencher (CLI) for more details.

BENCHMARKED MODULES
    Version numbers shown below are the versions used when running the
    sample benchmark.

    Array::AsObject 1.02

    Array::Set 0.062

    Array::Set::Naive 0.001

    Array::Utils 0.5

    List::Collection 0.0.4

    List::MoreUtils 0.428

    List::MoreUtils::PP 0.428

    Set::Array 0.30

    Set::Object 1.40

    Set::Scalar 1.29

    Set::Tiny 0.04

BENCHMARK PARTICIPANTS
    *   Array::Utils::unique (perl_code) [op:union]

        Code template:

         &Array::Utils::unique(<set1>, <set2>)

    *   Set::Scalar::union (perl_code) [op:union]

        Code template:

         my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->union($s2)

    *   List::MoreUtils::PP::uniq (perl_code) [op:union]

        Function call template:

         List::MoreUtils::PP::uniq(@{<set1>}, @{<set2>})

    *   List::MoreUtils::XS::uniq (perl_code) [op:union]

        Function call template:

         List::MoreUtils::uniq(@{<set1>}, @{<set2>})

    *   Array::Set::set_union (perl_code) [op:union]

        Function call template:

         Array::Set::set_union(<set1>, <set2>)

    *   Array::Set::Naive::set_union (perl_code) [op:union]

        Function call template:

         Array::Set::Naive::set_union(<set1>, <set2>)

    *   Set::Array::union (perl_code) [op:union]

        Code template:

         my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->union($s2)

    *   Array::AsObject::union (perl_code) [op:union]

        Code template:

         my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->union($s2, 1)

    *   Set::Object::union (perl_code) [op:union]

        Code template:

         my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->union($s2)

    *   Set::Tiny::union (perl_code) [op:union]

        Code template:

         my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->union($s2)

    *   List::Collection::union (perl_code) [op:union]

        Code template:

         [List::Collection::union(<set1>, <set2>)]

    *   Array::Utils::array_diff (perl_code) [op:symdiff]

        Code template:

         &Array::Utils::array_diff(<set1>, <set2>)

    *   Set::Scalar::symmetric_difference (perl_code) [op:symdiff]

        Code template:

         my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->symmetric_difference($s2)

    *   List::MoreUtils::PP::singleton (perl_code) [op:symdiff]

        Function call template:

         List::MoreUtils::PP::singleton(@{<set1>}, @{<set2>})

    *   List::MoreUtils::XS::singleton (perl_code) [op:symdiff]

        Function call template:

         List::MoreUtils::singleton(@{<set1>}, @{<set2>})

    *   Array::Set::set_symdiff (perl_code) [op:symdiff]

        Function call template:

         Array::Set::set_symdiff(<set1>, <set2>)

    *   Array::Set::Naive::set_symdiff (perl_code) [op:symdiff]

        Function call template:

         Array::Set::Naive::set_symdiff(<set1>, <set2>)

    *   Set::Array::symmetric_difference (perl_code) [op:symdiff]

        Code template:

         my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->symmetric_difference($s2)

    *   Array::AsObject::symmetric_difference (perl_code) [op:symdiff]

        Code template:

         my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->symmetric_difference($s2)

    *   Set::Object::symmetric_difference (perl_code) [op:symdiff]

        Code template:

         my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->symmetric_difference($s2)

    *   Set::Tiny::symmetric_difference (perl_code) [op:symdiff]

        Code template:

         my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->symmetric_difference($s2)

    *   List::Collection::complement (perl_code) [op:symdiff]

        Code template:

         [List::Collection::complement(<set1>, <set2>)]

    *   Array::Utils::array_minus (perl_code) [op:diff]

        Code template:

         &Array::Utils::array_minus(<set1>, <set2>)

    *   Set::Scalar::difference (perl_code) [op:diff]

        Code template:

         my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->difference($s2)

    *   Array::Set::set_diff (perl_code) [op:diff]

        Function call template:

         Array::Set::set_diff(<set1>, <set2>)

    *   Array::Set::Naive::set_diff (perl_code) [op:diff]

        Function call template:

         Array::Set::Naive::set_diff(<set1>, <set2>)

    *   Set::Array::difference (perl_code) [op:diff]

        Code template:

         my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->difference($s2)

    *   Array::AsObject::difference (perl_code) [op:diff]

        Code template:

         my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->difference($s2)

    *   Set::Object::difference (perl_code) [op:diff]

        Code template:

         my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->difference($s2)

    *   Set::Tiny::difference (perl_code) [op:diff]

        Code template:

         my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->difference($s2)

    *   List::Collection::subtract (perl_code) [op:diff]

        Code template:

         [List::Collection::subtract(<set1>, <set2>)]

    *   Array::Utils::intersect (perl_code) [op:intersect]

        Code template:

         &Array::Utils::intersect(<set1>, <set2>)

    *   Set::Scalar::intersection (perl_code) [op:intersect]

        Code template:

         my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->intersection($s2)

    *   Array::Set::set_intersect (perl_code) [op:intersect]

        Function call template:

         Array::Set::set_intersect(<set1>, <set2>)

    *   Array::Set::Naive::set_intersect (perl_code) [op:intersect]

        Function call template:

         Array::Set::Naive::set_intersect(<set1>, <set2>)

    *   Set::Array::intersection (perl_code) [op:intersect]

        Code template:

         my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->intersection($s2)

    *   Array::AsObject::intersection (perl_code) [op:intersect]

        Code template:

         my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->intersection($s2, 1)

    *   Set::Object::intersection (perl_code) [op:intersect]

        Code template:

         my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->intersection($s2)

    *   Set::Tiny::intersection (perl_code) [op:intersect]

        Code template:

         my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->intersection($s2)

    *   List::Collection::intersect (perl_code) [op:intersect]

        Code template:

         [List::Collection::intersect(<set1>, <set2>)]

BENCHMARK DATASETS
    *   num10

    *   num100

    *   num1000 (not included by default)

SAMPLE BENCHMARK RESULTS
    Run on: perl: *v5.30.2*, CPU: *Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz
    (4 cores)*, OS: *GNU/Linux LinuxMint version 19*, OS kernel: *Linux
    version 5.3.0-68-generic*.

    Benchmark with default options ("bencher -m SetOperationModules"):

     #table1#
     {dataset=>"num10",p_tags=>"op:diff"}
     +-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                 | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | Set::Scalar::difference     |     12000 |  81       |                 0.00% |              2147.13% |   2e-07 |      23 |
     | Array::AsObject::difference |     26000 |  39       |               107.15% |               984.78% |   4e-08 |      20 |
     | Set::Array::difference      |     70000 |  14.3     |               467.76% |               295.79% | 6.7e-09 |      20 |
     | Set::Object::difference     |    120000 |   8.3     |               880.78% |               129.12% | 1.3e-08 |      20 |
     | Array::Set::Naive::set_diff |    123482 |   8.09832 |               902.09% |               124.24% | 5.7e-12 |      25 |
     | Set::Tiny::difference       |    150000 |   6.8     |              1100.16% |                87.24% | 1.3e-08 |      20 |
     | List::Collection::subtract  |    188000 |   5.33    |              1423.25% |                47.52% | 1.7e-09 |      20 |
     | Array::Set::set_diff        |    240000 |   4.2     |              1831.85% |                16.32% |   5e-09 |      20 |
     | Array::Utils::array_minus   |    276900 |   3.61141 |              2147.13% |                 0.00% |   0     |      20 |
     +-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

     #table2#
     {dataset=>"num100",p_tags=>"op:diff"}
     +-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                 | rate (/s) | time (ms) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | Array::AsObject::difference |       480 |    2.1    |                 0.00% |              6402.49% | 4.1e-06 |      20 |
     | Set::Scalar::difference     |      2200 |    0.46   |               356.06% |              1325.78% | 6.9e-07 |      20 |
     | Array::Set::Naive::set_diff |      5400 |    0.19   |              1028.66% |               476.12% | 2.1e-07 |      21 |
     | Set::Array::difference      |     13000 |    0.074  |              2716.03% |               130.91% | 1.3e-07 |      22 |
     | Set::Object::difference     |     15000 |    0.065  |              3111.12% |               102.50% | 9.9e-08 |      23 |
     | Set::Tiny::difference       |     17000 |    0.059  |              3459.65% |                82.67% | 1.3e-07 |      20 |
     | Array::Set::set_diff        |     30000 |    0.033  |              6194.58% |                 3.30% |   5e-08 |      23 |
     | List::Collection::subtract  |     30700 |    0.0326 |              6307.72% |                 1.48% | 1.2e-08 |      23 |
     | Array::Utils::array_minus   |     31100 |    0.0321 |              6402.49% |                 0.00% | 1.1e-08 |      29 |
     +-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

     #table3#
     {dataset=>"num10",p_tags=>"op:intersect"}
     +----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                      | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | Set::Scalar::intersection        |   12000   |  86       |                 0.00% |              2247.59% |   1e-07 |      21 |
     | Array::AsObject::intersection    |   12000   |  82       |                 4.69% |              2142.42% | 1.1e-07 |      20 |
     | List::Collection::intersect      |   19000   |  53       |                61.78% |              1351.06% |   1e-07 |      22 |
     | Set::Array::intersection         |   32000   |  32       |               170.88% |               766.64% | 5.1e-08 |      22 |
     | Set::Object::intersection        |   98244.7 |  10.1787  |               740.40% |               179.34% | 5.8e-12 |      20 |
     | Array::Set::Naive::set_intersect |  103828   |   9.63133 |               788.16% |               164.32% | 5.8e-12 |      22 |
     | Set::Tiny::intersection          |  160000   |   6.2     |              1270.32% |                71.32% | 8.1e-09 |      21 |
     | Array::Set::set_intersect        |  189000   |   5.29    |              1516.38% |                45.24% | 1.6e-09 |      21 |
     | Array::Utils::intersect          |  274438   |   3.64381 |              2247.59% |                 0.00% |   0     |      20 |
     +----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

     #table4#
     {dataset=>"num100",p_tags=>"op:intersect"}
     +----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                      | rate (/s) | time (ms) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | Array::AsObject::intersection    |     240   | 4.3       |                 0.00% |             13169.36% | 5.3e-06 |      21 |
     | Set::Array::intersection         |     486   | 2.06      |               106.40% |              6328.92% | 1.8e-06 |      20 |
     | List::Collection::intersect      |    1370   | 0.73      |               482.00% |              2179.97% | 6.9e-07 |      20 |
     | Set::Scalar::intersection        |    2000   | 0.5       |               742.88% |              1474.29% | 8.3e-07 |      21 |
     | Array::Set::Naive::set_intersect |    4900   | 0.21      |              1964.66% |               542.69% | 2.1e-07 |      21 |
     | Set::Object::intersection        |   11000   | 0.089     |              4695.13% |               176.73% | 1.1e-07 |      20 |
     | Set::Tiny::intersection          |   18000   | 0.056     |              7446.19% |                75.84% | 1.1e-07 |      20 |
     | Array::Set::set_intersect        |   22500   | 0.0444    |              9473.74% |                38.60% | 1.2e-08 |      23 |
     | Array::Utils::intersect          |   31216.5 | 0.0320344 |             13169.36% |                 0.00% |   5e-12 |      21 |
     +----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

     #table5#
     {dataset=>"num10",p_tags=>"op:symdiff"}
     +---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                           | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | Array::AsObject::symmetric_difference |      5500 | 180       |                 0.00% |              7583.47% | 2.7e-07 |      20 |
     | List::Collection::complement          |      8400 | 120       |                53.43% |              4907.67% | 6.4e-07 |      20 |
     | Set::Scalar::symmetric_difference     |     19000 |  53       |               245.04% |              2126.86% |   8e-08 |      20 |
     | Array::Set::Naive::set_symdiff        |     35357 |  28.283   |               545.81% |              1089.74% | 4.6e-11 |      23 |
     | Set::Object::symmetric_difference     |     67000 |  15       |              1121.71% |               528.91% | 2.7e-08 |      20 |
     | Set::Array::symmetric_difference      |     71200 |  14       |              1200.88% |               490.63% | 6.5e-09 |      21 |
     | Set::Tiny::symmetric_difference       |    130000 |   7.4     |              2357.32% |               212.68% | 1.3e-08 |      20 |
     | Array::Set::set_symdiff               |    170000 |   5.8     |              3071.71% |               142.25% | 6.7e-09 |      20 |
     | Array::Utils::array_diff              |    220000 |   4.6     |              3864.59% |                93.80% | 6.7e-09 |      20 |
     | List::MoreUtils::PP::singleton        |    242000 |   4.14    |              4312.27% |                74.14% | 1.4e-09 |      27 |
     | List::MoreUtils::XS::singleton        |    420653 |   2.37726 |              7583.47% |                 0.00% |   0     |      20 |
     +---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

     #table6#
     {dataset=>"num100",p_tags=>"op:symdiff"}
     +---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                           | rate (/s) | time (ms) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | Array::AsObject::symmetric_difference |     116   | 8.62      |                 0.00% |             43587.49% | 1.2e-06 |      20 |
     | List::Collection::complement          |     550   | 1.8       |               371.84% |              9158.92% | 2.7e-06 |      20 |
     | Array::Set::Naive::set_symdiff        |    2020   | 0.495     |              1643.33% |              2405.98% | 4.8e-07 |      20 |
     | Set::Scalar::symmetric_difference     |    2900   | 0.34      |              2410.38% |              1640.27% | 4.2e-07 |      21 |
     | Set::Object::symmetric_difference     |   10000   | 0.1       |              8492.96% |               408.41% | 1.3e-07 |      20 |
     | Set::Array::symmetric_difference      |   13000   | 0.076     |             11297.33% |               283.31% | 9.9e-08 |      23 |
     | Set::Tiny::symmetric_difference       |   15000   | 0.065     |             13191.71% |               228.68% |   1e-07 |      21 |
     | Array::Set::set_symdiff               |   21600   | 0.0462    |             18545.58% |               134.30% | 1.3e-08 |      20 |
     | List::MoreUtils::PP::singleton        |   28000   | 0.036     |             23741.01% |                83.25% |   5e-08 |      23 |
     | Array::Utils::array_diff              |   27797.2 | 0.0359748 |             23864.84% |                82.30% | 2.3e-11 |      20 |
     | List::MoreUtils::XS::singleton        |   51000   | 0.02      |             43587.49% |                 0.00% |   2e-08 |      20 |
     +---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

     #table7#
     {dataset=>"num10",p_tags=>"op:union"}
     +------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                  | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | Set::Scalar::union           |   12000   |  84       |                 0.00% |              7441.85% | 1.1e-07 |      20 |
     | List::Collection::union      |   17000   |  59       |                42.10% |              5207.39% | 4.4e-07 |      21 |
     | Array::Set::Naive::set_union |   67752.2 |  14.7597  |               468.02% |              1227.75% | 5.8e-12 |      23 |
     | Array::AsObject::union       |   80800   |  12.4     |               577.60% |              1013.03% | 3.3e-09 |      21 |
     | Set::Array::union            |  100000   |   9.7     |               762.18% |               774.74% | 1.3e-08 |      21 |
     | Set::Object::union           |  116381   |   8.5925  |               875.70% |               672.97% |   0     |      20 |
     | Set::Tiny::union             |  150000   |   6.6     |              1175.41% |               491.33% | 1.3e-08 |      20 |
     | Array::Set::set_union        |  182000   |   5.48    |              1429.24% |               393.18% | 1.7e-09 |      20 |
     | List::MoreUtils::PP::uniq    |  318229   |   3.14239 |              2567.95% |               182.68% |   0     |      20 |
     | List::MoreUtils::XS::uniq    |  515000   |   1.94    |              4218.96% |                74.62% | 8.3e-10 |      20 |
     | Array::Utils::unique         |  900000   |   1.11    |              7441.85% |                 0.00% | 4.1e-10 |      21 |
     +------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

     #table8#
     {dataset=>"num100",p_tags=>"op:union"}
     +------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | participant                  | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
     +------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
     | List::Collection::union      |     920   | 1100      |                 0.00% |             28313.54% | 1.3e-06 |      21 |
     | Set::Scalar::union           |    2070   |  484      |               124.70% |             12545.09% | 4.8e-07 |      20 |
     | Array::Set::Naive::set_union |    2900   |  350      |               210.18% |              9060.44% | 4.3e-07 |      20 |
     | Array::AsObject::union       |   12000   |   87      |              1153.76% |              2166.27% | 2.1e-07 |      20 |
     | Set::Object::union           |   14000   |   72      |              1418.92% |              1770.64% |   1e-07 |      21 |
     | Set::Tiny::union             |   17000   |   60      |              1711.03% |              1468.92% | 9.2e-08 |      27 |
     | Set::Array::union            |   22000   |   46      |              2267.06% |              1100.37% | 5.2e-08 |      21 |
     | Array::Set::set_union        |   21900   |   45.8    |              2276.42% |              1095.65% |   4e-08 |      20 |
     | List::MoreUtils::PP::uniq    |   36848.1 |   27.1384 |              3906.17% |               609.24% |   0     |      20 |
     | List::MoreUtils::XS::uniq    |   65000   |   15      |              6934.26% |               303.93% | 2.7e-08 |      20 |
     | Array::Utils::unique         |  261000   |    3.83   |             28313.54% |                 0.00% | 1.7e-09 |      20 |
     +------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

    Benchmark module startup overhead ("bencher -m SetOperationModules
    --module-startup"):

     #table9#
     +---------------------+-----------+-------------------+-----------------------+-----------------------+-----------+---------+
     | participant         | time (ms) | mod_overhead_time | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors   | samples |
     +---------------------+-----------+-------------------+-----------------------+-----------------------+-----------+---------+
     | Array::AsObject     |      20   |              15   |                 0.00% |               251.58% |   0.00018 |      20 |
     | Set::Array          |      20   |              15   |                 6.54% |               230.00% |   0.0002  |      21 |
     | List::Collection    |      16   |              11   |                12.78% |               211.73% |   0.00011 |      20 |
     | Set::Object         |      10   |               5   |                28.02% |               174.64% |   0.00014 |      20 |
     | Set::Scalar         |      13   |               8   |                42.28% |               147.11% | 3.4e-05   |      20 |
     | List::MoreUtils     |      12   |               7   |                53.89% |               128.46% | 3.7e-05   |      20 |
     | List::MoreUtils::PP |       9.1 |               4.1 |                96.61% |                78.82% | 3.2e-05   |      20 |
     | Array::Set::Naive   |       9   |               4   |               109.72% |                67.64% |   0.00017 |      21 |
     | Array::Set          |       8   |               3   |               121.13% |                59.00% |   0.00015 |      20 |
     | Set::Tiny           |       7   |               2   |               150.59% |                40.30% |   0.00023 |      21 |
     | Array::Utils        |       6   |               1   |               186.55% |                22.69% |   0.00024 |      20 |
     | perl -e1 (baseline) |       5   |               0   |               251.58% |                 0.00% |   0.0001  |      20 |
     +---------------------+-----------+-------------------+-----------------------+-----------------------+-----------+---------+

    To display as an interactive HTML table on a browser, you can add option
    "--format html+datatables".

HOMEPAGE
    Please visit the project's homepage at
    <https://metacpan.org/release/Bencher-Scenario-SetOperationModules>.

SOURCE
    Source repository is at
    <https://github.com/perlancar/perl-Bencher-Scenario-SetOperationModules>
    .

BUGS
    Please report any bugs or feature requests on the bugtracker website
    <https://rt.cpan.org/Public/Dist/Display.html?Name=Bencher-Scenario-SetO
    perationModules>

    When submitting a bug or request, please include a test-file or a patch
    to an existing test-file that illustrates the bug or desired feature.

SEE ALSO
    Benchmark::Featureset::SetOps

    Excluded modules: Set::Bag (expects hashes instead of arrays),
    Set::SortedArray (members are sorted).

AUTHOR
    perlancar <perlancar@cpan.org>

COPYRIGHT AND LICENSE
    This software is copyright (c) 2021, 2017, 2016, 2015 by
    perlancar@cpan.org.

    This is free software; you can redistribute it and/or modify it under
    the same terms as the Perl 5 programming language system itself.