Olzhas Zhumabek simmplecoder

`std::call`

The purpose of std::call is to enable std::apply on non tuple arguments, and make it viable even for multi argument cases.

Current situation:

Lets consider some usage cases:

//first example
template <typename ... Types>
void process_instance(std::size_t id, Types&amp;&amp; ... args);

	#pragma once

	#include <chrono>
	#include <utility>

	template <class Func, class ... Args>
	std::chrono::duration<double> measure(Func function, Args&& ... args)
	{
	auto start = std::chrono::high_resolution_clock::now();
	function(std::forward<Args>(args)...);

	template <typename Engine = std::mt19937>
	class random_bits_generator
	{
	Engine engine;
	std::bernoulli_distribution distribution;
	public:
	template <typename OutputIt>
	void operator()(OutputIt first, OutputIt last)
	{
	while (first != last)

	#ifndef PRIME_NUMBERS_H
	#define PRIME_NUMBERS_H

	#include <vector>
	#include <algorithm>

	template <typename NumberType>
	/*
	NumberType requires:
	Construction from unsigned int;

	#pragma once
	#include <vector>

	template<typename T>
	struct SimpleDestructableTrivialy
	{
	static constexpr bool value = std::is_trivially_destructible<T>::value;
	};
	template<typename T, bool = SimpleDestructableTrivialy<T>::value>
	class SimpleDestroy

	#pragma once

	#include <numeric>

	namespace impl_details
	{
	template <typename T, typename UnaryAdvanceOp>
	class proxy
	{
	T value;

	#define EPSILON 0.001
	#include <utility>
	#include <bitset>
	#include <cassert>
	#include <iostream>

	template <std::size_t dimensions>
	using quadrant = std::bitset<dimensions>;

	template <typename T>

	#include <cstddef>
	#include <type_traits>
	#include <cstring>

	namespace playground
	{
	template<typename T>
	struct count_indirections
	{
	static constexpr std::size_t value = 0;