Дмитрий Беляев

import typing as tp


class Test:
    @tp.overload
    def __init__(self, x: int, y: str):
        ...  # тут не должно быть тела!

    @tp.overload
    def __init__(self, other: 'Test'):
        ...  # typehint в виде строки, так как класс Test еще не создан. Тела нет!

    def __init__(self, *args, **kwargs):  # настоящий конструктор
        # определяем, как нас вызвали
        if 'other' in kwargs:
            first_arg = kwargs['other']
            x, y = first_arg.x, first_arg.y
        elif 'x' in kwargs:
            x, y = kwargs.get('x'), kwargs.get('y')
        elif isinstance(args[0], Test):
            x, y = args[0].x, args[0].y
        else:
            x, y = args[0:2]
        self.x: int = x
        self.y: str = y

    def __repr__(self) -> str:
        return f'Test(x={self.x!r}, y={self.y!r})'

# порядковая передача аргументов сработает
t1 = Test(1, 'foo')
t2 = Test(t1)
print(t1, t2)
# именованная передача аргументов сработает
t3 = Test(x=2, y='bar')
t4 = Test(other=t3)
print(t3, t4)

Test(3, y='baz')  # а вот это сломается...

#include <stdio.h>

enum Opcode {
    OP_LOAD_ARGUMENT,
    OP_LOAD_STRING,
    OP_SUBTRACT,
    OP_GOTO,
    OP_GOTO_IF_TRUE,
    OP_CALL,
    OP_RETURN
};

union Argument {
    int value;
    const void* pointer;
};

struct Instruction { 
    Opcode opcode; 
    Argument arg; 
};

void run_vm(const Instruction* instructions, const Argument* args) {
    Argument stack[16];
    
    Argument* stack_pointer = &stack[0];
    int address = 0;

    while(true) {
        const Instruction instruction = instructions[address];
        address++;

        switch(instruction.opcode) {
            case OP_RETURN:
                return;
            
            case OP_LOAD_ARGUMENT:
                *stack_pointer = args[instruction.arg.value];
                stack_pointer++;
                break;

            case OP_LOAD_STRING:
                *stack_pointer = instruction.arg;
                stack_pointer++;
                break;

            case OP_SUBTRACT:
            {
                stack_pointer--;
                int b = stack_pointer->value;
                
                stack_pointer--;
                int a = stack_pointer->value;

                stack_pointer->value = a - b;
                stack_pointer++;
                break;
            }

            case OP_GOTO:
                address = instruction.arg.value;
                break;

            case OP_GOTO_IF_TRUE:
                stack_pointer--;
                if(stack_pointer->value != 0)
                    address = instruction.arg.value;
                break;

            case OP_CALL:
                void (* fn)(const void*) = (void (*)(const void*))instruction.arg.pointer;
                stack_pointer--;
                fn(stack_pointer->pointer);
                break;
        }
    }
}

void print(const char* text) { printf("%s\n", text); }

int main(int argc, char** argv) {
    const Instruction instructions[] = {
        /* 0 */ { OP_LOAD_ARGUMENT, { 0 } },
        /* 1 */ { OP_LOAD_ARGUMENT, { 1 } },
        /* 2 */ { OP_SUBTRACT, {} },
        /* 3 */ { OP_GOTO_IF_TRUE, { 0x7 } },
        /* 4 */ { OP_LOAD_STRING, { .pointer = "zero" } },
        /* 5 */ { OP_CALL, { .pointer = (void*)&print } }, // функции надо где-то регистрировать, чтобы знать сколько у них параметров и какого они типа
        /* 6 */ { OP_GOTO, { 0x9 } },
        /* 7 */ { OP_LOAD_STRING, { .pointer = "not zero" } },
        /* 8 */ { OP_CALL, { .pointer = (void*)&print } },
        /* 9 */ { OP_LOAD_STRING, { .pointer = "done" } },
        /* A */ { OP_CALL, { .pointer = (void*)&print } },
        /* B */ { OP_RETURN, {} }
    };

    const Argument args[] = { 
        { 100500 },
        { 777 }
     };

    run_vm(instructions, args);
    return 0;
}