if (value, err := foo("hi"); err == 0) {
}

B>if (value, err := foo("hi"); err == 0) {
B>}
B>

auto foo(const char *)
{
    struct
    {
        int value, err;
    } result = {1, 0};
    return result;
}

int main()
{
    if(auto [value, err] = foo("hi"); err == 0)
    {
        cout << "true";
    }
}

Go is mostly in the C family (basic syntax), with significant input from the Pascal/Modula/Oberon family (declarations, packages), plus some ideas from languages inspired by Tony Hoare's CSP, such as Newsqueak and Limbo (concurrency)

·>

auto foo(const char *)
{
    struct
    {
        int value, err;
    } result = {1, 0};
    return result;
}

int main()
{
    if(auto [value, err] = foo("hi"); err == 0)
    {
        cout << "true, value=" << value;
    }
    else
    {
        cout << "false, value=" << value;
    }
}

AK>>Зачем?

It is important to note that the TIOBE index is not about the best programming language or the language in which most lines of code have been written.

stackfulness

In contrast to a stackless coroutine a stackful coroutine can be suspended from within a nested stackframe.
Execution resumes at exactly the same point in the code where it was suspended before. With a stackless coroutine,
only the top-level routine may be suspended. Any routine called by that top-level routine may not itself suspend.
This prohibits providing suspend/resume operations in routines within a general-purpose library.

a stackful coroutine can be suspended from within a nested stackframe.
Execution resumes at exactly the same point in the code where it was suspended before

With a stackless coroutine, only the top-level routine may be suspended. Any routine called by that top-level routine may not itself suspend

async Action* ParseSIPPacket(FrameSource f) {
   udpPacket = parseUdpPacket(f)
   // Parse SIP packet
...
}

async UDPPacket* ParseUDPPacket(FrameSource f) {
   ipPacket = parseIPPacket(f)
   // Parse UDP packet
...
}

async IPPacket* ParseIPPacket(FrameSource f) {
   ipPacket = parseEthPacket(f)
   // Parse IP packet
...
}

async EthPacket* ParseEthPacket(FrameSource f) {
    int packetLen = readPacketLen(f) //Might block
    char buf[packetLen];
    for(int i=0; i<packetLen; ++i) buf[i] = f.readByte(); //Might block

    return new EthPacket(buf);
}

·>И это там утечки подпрограмм, да?

// Создаём канал для вывода
var output = make(chan int64)

// "Запускаем" генератор
go func() {
   for i := 0; i < 10; i++ {
       output <- i // Возвращаем значение
   }
   close(output)
} ()

// В основном потоке читаем
for {
  val, ok := <- output
  if !ok {
     break
  }
  print(val)
}

#include <boost/coroutine2/all.hpp>
#include <iostream>

int main()
{    
    using namespace boost::coroutines2;

    coroutine<int>::pull_type coro([](auto &yield)
    {
        for(int i=0; i!=10; ++i)
            yield(i);
        for(int j=5; j!=0; --j)
            yield(j);
    });

    for(auto x : coro)
        std::cout << x << " ";
}

auto generator()
{
    for(int i=0; i!=10; ++i)
        yield i;
    for(int j=5; j!=0; --j)
        yield j;
}

class Generator
{
    int i, j;
    int state = 0;
public:
    optional<int> operator()()
    {
        switch(state)
        {
            case 0:
                for(i=0; i!=10; ++i)
                {
                    state = 1;
                    return i;
            case 1:;
                }
                state = 2;
            case 2:
                for(j=5; j!=0; --j)
                {
                    state = 3;
                    return j;
            case 3:;
                }
                state = 4;
            case 4:;
        }
        return {};
    }
};

массовый ЯП должен быть понятен сходу таким как я или студентам первашам

Зачем?

проф. программисты изобретают более сложные ЯП, чтоб стать еще более проф-м программатором

Нет, чтобы решать все более сложные задачи все эффнктивнее