#include <iostream>

auto fun()
{
    int i = 1;
    return i;
}

auto fun2()
{
    enum Result : int { a, b, c };
    Result e = a;
    return e;
}


auto fun3()
{
    struct st{ int m_a; int m_b; };
    st t;
    t.m_a = 1;
    t.m_b = 2;
    
    return t;
}


int main()
{
    std::cout << fun() << std::endl;
    
    auto e1 = fun2();
    auto e2 = fun2();
    
    std::cout << "e1 == e2 - " << (e1 == e2 ? "true" : "false") << std::endl;
    std::cout << "e1 == b - " << (e1 == decltype(e1)::b ? "true" : "false") << std::endl;

    auto t = fun3();
    
    std::cout << "t.m_a = " << t.m_a << std::endl;
    std::cout << "t.m_b = " << t.m_b << std::endl;
    return 0;
}

enum class FunResult
{
  Ok,
  WrongFormat,
  DeviceError
};


FunResult fun()
{
  return FunResult::Ok;
}

enum class
{
  Ok,
  WrongFormat,
  DeviceError
} fun()
{
  return FunResult::Ok;
}

auto Get(int i)
{
  struct Result
  {
     int m_nValue;
     int m_nKey;
  };

  Result res = { 2, 3 };

  return res;
}

// Вместо:
class X
{
  struct Restult {...};
  
  Result some_function();
}
// Делать:
class X
{
  auto some_function()
  {
    // А тут что-то, что требует 100500 заголовков...
    return {...};
  }
}

auto number = std::stod("10.0");

auto number = std::stod("10.0").result;

namespace std {
format_result<double> stod(const string&)
{
  return ...;
}
}

V>неименованые структуры и раньше можно было тайпдефить, ауто и раньше в разные типы превращалось, — не понятно в чём открытие.

auto f() {
  struct T {}; 
  return T();
}

V>>>неименованые структуры и раньше можно было тайпдефить, ауто и раньше в разные типы превращалось, — не понятно в чём открытие.

auto fun3()
{
    struct { int m_a; int m_b; } t;
    t.m_a = 1;
    t.m_b = 2;
     
    return t;
}

auto fun_test()
{
    //...
    return { int error_code = 1, error_status = obj.status; string description = obj.description; };
}

UA>auto fun_test()
UA>{
UA>    //...
UA>    return { int error_code = 1, error_status = obj.status; string description = obj.description; };
UA>}
UA>

auto fun_test()
{
    return NEW((error_code, 1)(error_status, obj.status)(description, obj.description));
}

auto fun_test()
{
    //...
    return class { public: int error_code = 1, error_status = obj.status; string description = obj.description; };
}

UA>auto fun_test()
UA>{
UA>    //...
UA>    return class { public: int error_code = 1, error_status = obj.status; string description = obj.description; };
UA>}
UA>

auto fun_test()
{
    //...
    /* const */ class { public: int error_code = 1, error_status = obj.status; string description = obj.description; } t;
    return t;
}

V>>>Я к тому это, что сообщения с префиксом [trick] здесь пишут, если в коде имеется действительно какой-то трюк или хинт с кодом, чтобы добиться желаемого. Но в приведённом тобой коде я трюков никаких не увидел, зато увидел применение обычного синтаксиса поддерживаемого самим языком. Это не является трюком.

auto fun3()
{
    struct st{ int m_a; int m_b; };
    st t;
    t.m_a = 1;
    t.m_b = 2;
    
    return t;
}

auto extended_fread()
{
   return {errcode=e, bytes=b};
}

main()
{
   auto r = extended_fread();
   if (r.errcode) {...}
   ptr += r.bytes;
}

auto bytes_read = fread(...)./*что тут писать, просить помощи у IDE?*/

int bytes_read = fread(...).bytes_read; // Отлично

auto result = fread(...);
if (!result.error)
{
  int bytes_read = result.bytes_read;
}

extern auto fun();

W>auto number = std::stod("10.0");
W>

W>auto number = std::stod("10.0").result;
W>

W>namespace std {
W>format_result<double> stod(const string&)
W>{
W>  return ...;
W>}
W>}
W>

BFE>>>enum class FunResult
BFE>>>{
BFE>>>  Ok,
BFE>>>  WrongFormat,
BFE>>>  DeviceError
BFE>>>};
BFE>>>FunResult fun()
BFE>>>{
BFE>>>  return FunResult::Ok;
BFE>>>}
BFE>>>

auto fun()
{
    enum class ResStatus
    {
      Ok,
      WrongFormat,
      DeviceError
    };
  //<...>
  return ResStatus::Ok;
}


void main(void)
{
    const fun::ResStatus res = f();
 
    if(fun::ResStatus::ok == res)
    {
       //<...>
    }
    else
   {
      //<...>
   };
}

extern auto fun();
int main()
{
  auto retval = fun();
  return sizeof(retval);
}

Of course, using such a function in an expression when only a forward declaration has been seen is ill-formed:

auto f();    // return type is unknown
int i = f(); // error, return type of f is unknown

#include <iostream>
#include <type_traits>

using namespace std;

auto f()
{
  enum class A { X, Y };
  
  return A::X;
}

auto f(int)
{
  enum class A { X, Y };
  
  return A::X;
}

int main()
{
  auto fvoid = f();
  
  auto fint = f(1);
  
  cout << is_same<decltype(fvoid), decltype(fint)>::value; // 0
}

_NN>#include <iostream>
_NN>#include <type_traits>

_NN>using namespace std;

_NN>auto f()
_NN>{
_NN>  enum class A { X, Y };
  
_NN>  return A::X;
_NN>}

_NN>auto f(int)
_NN>{
_NN>  enum class A { X, Y };
  
_NN>  return A::X;
_NN>}

_NN>int main()
_NN>{
_NN>  auto fvoid = f();
  
_NN>  auto fint = f(1);
  
_NN>  cout << is_same<decltype(fvoid), decltype(fint)>::value; // 0
_NN>}
_NN>

struct f
{  
    enum class Res{ok, failed}; 

    Res operator()(){return Res::ok;}
};

void main()
{
    list<f::Res> ResLog;

    for(int i = 0; i < 100; ++i)
    {
         f::Res res = f()();// а хотелось бы f()

         ResLog.push_back(res);
    };    
}

__>auto fun()
__>{
__>    enum class ResStatus
__>    {
__>      Ok,
__>      WrongFormat,
__>      DeviceError
__>    };
__>  //<...>
__>  return ResStatus::Ok;
__>}


__>void main(void)
__>{
__>    const fun::ResStatus res = f();
 
__>    if(fun::ResStatus::ok == res)
__>    {
__>       //<...>
__>    }
__>    else
__>   {
__>      //<...>
__>   };
__>}
__>

struct fun {
    enum ResultStatus { 
        Ok,
        WrongFormat,
        DeviceError };

        static ResultStatuc Call();


};

E>struct fun {
E>    enum ResultStatus { 
E>        Ok,
E>        WrongFormat,
E>        DeviceError };

E>        static ResultStatuc Call();
E>};

struct fun
{
    enum ResultStatus { 
        Ok,
        WrongFormat,
        DeviceError };

        static ResultStatuc Call();
        static ResultStatuc Call(int count);
};

__>>struct f
__>>{  
__>>    enum class Res{ok, failed}; 

__>>    Res operator()(){return Res::ok;}
__>>};
__>>

__>а чем методы хуже? им что не надо возвращать коды ошибок?

enum FunResult { ... };
FunResult fun(...

__>>>struct f
__>>>{  
__>>>    enum class Res{ok, failed}; 

__>>>    Res operator()(){return Res::ok;}
__>>>};
__>>>

__>>а чем методы хуже? им что не надо возвращать коды ошибок?

enum FunResult { ... };
E>FunResult fun(...

E>>>что конкретно? То, что надо fun::call писать? если честно не понимаю, чем auto fun() так уж сильно отличается... слово auto короче? или в чём фишка?

class CFoo
{
  static
  auto fun()
  {  
     enum class Res{ok, failed};
     //<....>
     return res;
  }
};

class CFoo
{
  struct fun 
  {
     enum class Res{ok, failed};
     static 
     Res Call()
     {
        //<....>
        return res;
     }
  };
};