286.md

Info

• Did you know that Circle supports Python's extended slice syntax for variadic packs?

  • https://docs.python.org/2.3/whatsnew/section-slices.html
  • https://github.com/seanbaxter/circle/blob/master/comprehension/README.md

Example

auto foo(auto... ts) {
    // syntax: ...[start:stop:step]
    std::cout << ts...[0] << '\n';             // prints first element
    ((std::cout << ts...[0:2]), ...) << '\n';  // prints frist two elemetns
    ((std::cout << ts...[::2]), ...) << '\n';  // prints every second
    ((std::cout << ts...[::-1]), ...) << '\n'; // prints in reverse
}

int main() {
    foo(1, 2, 3, 4);
}

https://circle.godbolt.org/z/Pj7E5cPe1

Puzzle

• Can you add missing extened slice expressions on variadic packs to match the requirements?

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...};    }(1, 2, 3)); // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/33P78nG7e

Solutions

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3));  // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{ts...[2]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{ts...[::-1] ...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{ts...[1:3] ...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{ts...[1::2] ...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...[0:sizeof...(ts)/2] ...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2:] ...}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/Gn8WETGMY

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3));  // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{ts...[-3:]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts)/2]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2:]...}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/7b3f5T7bf

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3));  // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{ts...[-3:-1:1]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // evens
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts)/2:]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2::]...}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/fEdn1G6r7

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3));  // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{ts...[-3:]... /*[-2:]*/}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts)/2]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2:]...}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/rvh4YGnx6

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3));  // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{ts...[1:3]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts) / 2]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{ts...[sizeof...(ts) / 2:]...}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/qxbbWv4o1

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3));  // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{ts...[1:]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...[:3]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{ts...[3:]...}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/sW7hccoE7

static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3));  // identity
static_assert(std::tuple{2}        == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3}        == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1}  == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3}     == [](auto... ts) { return std::tuple{ts...[-3:]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4}     == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3}  == [](auto... ts) { return std::tuple{ts...[0:3]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6}  == [](auto... ts) { return std::tuple{ts...[3:]...}; }(1, 2, 3, 4, 5, 6)); // second half

https://circle.godbolt.org/z/7cnWsP5Mq