Titles:
  name: Name
  inputs: 'Input Ranges<a href="#fn-stagger">*</a>'
  acc: Accumulator
  outputs: Output
  ops: 'Operations<a href="#fn-opabbrs">&dagger;</a>'
  defaults: Default operations
  order: In-order
  basis: Based on
  family: ''

Catamorphisms: 
  - {name: 'accumulate', lib: 'std',
     inputs: '1', acc: 'Arg', outputs: 'Value',
     ops: 'A', defaults: 'plus', order: 'Yes',
     iter: '(x:[T], a:U, o:A) -> a{n} = o(a, x{i}) -> a',
     basis: '', family: '0'}
  - {name: 'sum', lib: 'kblib',
     inputs: '1', acc: 'First', outputs: 'Value',
     ops: 'A', defaults: 'plus', order: 'Yes',
     iter: '(x:[T], o:A) (a = head x, y = tail x) -> a{n} = o(a, y{i}) -> a',
     basis: 'std::accumulate', family: '0'}
  - {name: 'reduce', lib: 'std',
     inputs: '1', acc: 'Arg', outputs: 'Value',
     ops: 'acR', defaults: 'plus', order: 'No',
     iter: '(x:[T], b:T, o:acR) (y: cat b x) -> a{n} = o(a, y{i}) -> a',
     basis: '', family: '0'}
  - {name: 'inner_product', lib: 'std',
     inputs: '2', acc: 'Arg', outputs: 'Value',
     ops: 'A, bT', defaults: 'plus, multiplies', order: 'Yes',
     iter: '(x:[T1], y:[T1], a:U, s:A, p:bT) -> a{n} = s(a, p(x{i}, y{i})) -> a',
     basis: '', family: '1'}
  - {name: 'adjacent_reduce', lib: 'CH',
     inputs: '1s', acc: 'Arg', outputs: 'Value',
     ops: 'A, bT', defaults: '-', order: 'Yes',
     iter: '(x:[T], a:U, s:A, p:bT) -> a{n} = s(a, p(x{i}, x{i+1})) -> a',
     basis: 'std::inner_product', family: '1'}
  - {name: 'transform_reduce(1)', lib: 'std',
     inputs: '1', acc: 'Arg', outputs: 'Value',
     ops: 'acR, uT', defaults: 'plus, multiplies', order: 'No',
     iter: '(x:[T], a:U, o:R, p:uT) -> a{n} = o(a, p(x{i})) -> a',
     basis: '', family: '3'}
  - {name: 'transform_reduce(2)', lib: 'std',
     inputs: '2', acc: 'Arg', outputs: 'Value',
     ops: 'acR, bT', defaults: 'plus, multiplies', order: 'No',
     iter: '(x:[T1], y:[T2], a:U, o:R, p:bT) -> a{n} = o(a, p(x{i}, y{i})) -> a',
     basis: '', family: '3'}
  - {name: 'adjacent_find', lib: 'std',
     inputs: '1s', acc: 'No', outputs: 'Position',
     ops: 'bP', defaults: 'equal_to', order: 'Yes (short-circuits)',
     iter: '(x:[T], p:bP) -> p(x{i}, x{i+1}) ? -> x+i',
     basis: '', family: '7'}
  - {name: 'find(1)', lib: 'std',
     inputs: '1', acc: 'No', outputs: 'Position',
     ops: 'Value', defaults: '-', order: 'Yes (short-circuits)',
     iter: '(x:[T], a:U) -> x{i} == a ? -> x+i',
     basis: '', family: '9'}
  - {name: 'find(2)', lib: 'std',
     inputs: '1', acc: 'No', outputs: 'Position',
     ops: 'Value / uP', defaults: '-', order: 'Yes (short-circuits)',
     iter: '(x:[T], p:uP) -> p(x{i}) ? -> x+i',
     basis: '', family: '9'}

Anamorphisms:
  - {name: 'transform_inclusive_scan(1)', lib: 'std',
     inputs: '1', acc: 'First',
     ops: 'aR, uT', defaults: '-', order: 'No',
     iter: '(x:[T], d:[U], o:aR, p:uT) a=head x -> d{i} = a{n} = o(a, p(x{i})) -> d',
     basis: '', family: '3'}
  - {name: 'transform_inclusive_scan(2)', lib: 'std',
     inputs: '1', acc: 'Arg',
     ops: 'aR, uT', defaults: '-', order: 'No',
     iter: '(x:[T], d:[U], o:aR, p:uT, a:U) -> d{i} = a{n} = o(a, p(x{i})) -> d',
     basis: '', family: '3'}
  - {name: 'transform_exclusive_scan', lib: 'std',
     inputs: '1', acc: 'Arg',
     ops: 'aR, uT', defaults: '-', order: 'No',
     iter: '(x:[T], d:[U], o:aR, p:uT, a:U) d{0} = a -> d{i} = a{n} = o(a, p(x{i+1})) -> d',
     basis: '', family: '3'}
  - {name: 'partial_sum', lib: 'std',
     inputs: '1', acc: 'First',
     ops: 'A', defaults: 'plus', order: 'Yes',
     iter: '(x:[T], d:[U], o:A) a = x{0} -> d{i} = a{n} = o(a, x{i}) -> d',
     basis: '', family: '4'}
  - {name: 'inclusive_scan(1)', lib: 'std',
     inputs: '1', acc: 'First',
     ops: 'aR', defaults: 'plus', order: 'No',
     iter: '(x:[T], d:[U], o:aR) a = x{0} -> d{i} = a{n} = o(a, x{i}) -> d',
     basis: '', family: '4'}
  - {name: 'inclusive_scan(2)', lib: 'std',
     inputs: '1', acc: 'Arg',
     ops: 'aR', defaults: 'plus', order: 'No',
     iter: '(x:[T], d:[U], o:aR, a:U) -> d{i} = a{n} = o(a, x{i}) -> d',
     basis: '', family: '4'}
  - {name: 'exclusive_scan', lib: 'std',
     inputs: '1', acc: 'Arg',
     ops: 'aR', defaults: 'plus', order: 'No',
     iter: '(x:[T], d:[U], o:aR) a = x{0} -> d{i} = a{n} = o(a, x{i+1}) -> d',
     basis: '', family: '4'}
  - {name: 'adjacent_difference', lib: 'std',
     inputs: '1s', acc: 'Quasi',
     ops: 'fD', defaults: 'minus', order: 'Yes / No',
     iter: '(x:[T], d:[U], o:fD) d{0} = x{0} -> d{i+1} = o(x{i+1}, x{i}) -> d',
     basis: '', family: '5'}
  - {name: 'adjacent_transform', lib: 'CH',
     inputs: '1s', acc: 'Quasi',
     ops: 'D', defaults: '-', order: 'Yes / No',
     iter: '(x:[T], d:[U], o:D) d{0} = x{0} -> d{i+1} = o(x{i}, x{i+1}) -> d',
     basis: 'std::adjacent_difference', family: '5'}
  - {name: 'adjacent_inclusive_scan', lib: 'CH',
     inputs: '1s', acc: 'First',
     ops: 'A, fD', defaults: '-', order: 'Yes',
     iter: '(x:[T], d:[U], o:A, p:D) d{0} = a = x{0} -> d{i+1} = a = o(a, p(x{i+1}, x{i})) -> d',
     basis: '', family: '6'}
  - {name: 'transform(1)', lib: 'std',
     inputs: '1', acc: 'No',
     ops: 'uT', defaults: '-', order: 'Yes',
     iter: '(x:[T], d:[U], o:uT) -> d{i} = o(x{i}) -> d',
     basis: '', family: '8'}
  - {name: 'transform(2)', lib: 'std',
     inputs: '2', acc: 'No',
     ops: 'uT / bT', defaults: '-', order: 'Yes',
     iter: '(x:[T], y:[U], d:[V], o:bT) -> d{i} = o(x{i}, y{i}) -> d',
     basis: '', family: '8'}
  - {name: 'iota', lib: 'std',
     inputs: 'Value', acc: 'Arg',
     ops: '-', defaults: '%R%increment%', order: 'Yes',
     iter: '(d:[U], a:T) -> d{i} = ++a -> ()',
     basis: '', family: '10'}
 
# ^(.+)@(.+)@(.+)@(.+)@(.+)@(.+)@(.+)@(.+)@(.+)$

urls:
  common:
    std: ['https://en.cppreference.com/w/cpp/', '([a-z_])(_if|_if_not)?', 'algorithm/\1']
    kblib: ['', '']
  exceptions:
    std:
      ['all_of', 'any_of', 'none_of']: @/all_any_none_of
      ['ranges::starts_with']: @/ranges/starts_with
      ['ranges::ends_with']: @/ranges/ends_with
      ['shift_left', 'shift_right']: @/shift
      ['shuffle']: @/random_shuffle