using std::string, std::cout, std::endl, std::stoi, std::istringstream, std::ostream;

template <class T>
struct MyParser {
   static T parse(string inp);
};

struct MyUser {
   string name;
   int age;
   friend ostream &operator<<(ostream &ss, const MyUser &u) {
       return ss << "User(name: \"" << u.name << "\", age: " << u.age << ")";
   }
};

// Імпли парсерів
// Для інта
template <>
struct MyParser<int> {
   static int parse(string inp) {
       return stoi(inp);
   }
};

// Для MyUser
template <>
struct MyParser<MyUser> {
   static MyUser parse(string inp) {
       istringstream ss(inp);
       string name, sage;
       ss >> name;
       ss >> sage;
       return MyUser{name, stoi(sage)};
   }
};

int main() {
   auto user = MyParser<MyUser>::parse("Jon 71");
   auto i = MyParser<int>::parse("69");
   cout << user << endl;
   cout << i << endl;
   return 0;
}

struct POD
{
   float a;
   std::string b;
   int c;
   unsigned d;
   double e;

   friend std::istream& operator>>(std::istream&, POD&);
   friend std::ostream& operator<<(std::ostream&, const POD&);
};

std::istream& operator>>(std::istream& from, POD& p)
{
   from >> p.a;
   from >> p.b;
   from >> p.c;
   from >> p.d;
   from >> p.e;

   return from;
}

std::ostream& operator<<(std::ostream& to, const POD& p)
{
   to << p.a << "\n";
   to << p.b << "\n";
   to << p.c << "\n";
   to << p.d << "\n";
   to << p.e << "\n";

   return to;
}

template <typename T>
std::optional<T> TryParse(std::istream& from)
{
   T retval;
   if(from >> retval) {
       return {retval};
   }
   from.clear();
   return {};
}


int main()
{
   std::istringstream ss{"1 sd 3 4 5"};

   assert(TryParse<int>(ss));
   assert(!TryParse<int>(ss));

   std::string s;
   ss >> s;
   
   assert(TryParse<int>(ss));

   std::istringstream ss2{"1 sd 3 4 5"};

   auto pod = TryParse<POD>(ss2);

   assert(pod);…