E>Как там сделать хотя бы скромный полиморфизм? Я думаю, что органично предлагать решения на С++, но главное тут не язык, а идеи

int do_foo(int id_foo, x,y,z) {
  switch(id_foo) {
  case 0: pure_virtual_function_call();
  case 1: return A__foo(x,y,z);
  case 2: return B__foo(x,y,z);
  ...
  default: virtual_method_table_corrupted();
}

E>Синтаксические конструкции похожие будут... Ну, например, в куске кода, где возможны виртуальные вызовы, наверное надо будет перечислять доступные реализации...

class Base {
    virtual int calc() { return 0; }
};

class Derived : public Base {
    virtual int calc() override { return Base::calc() + 1; }
};

...
Base * base = getObj();
return base->calc();

class Base
{
   void * typeId_;    

   static void __call_virtual__calc(Base * obj) 
   {
      switch(typeId_)
      {
      case __type_id__Base: return obj->calc();
      case __type_id__Derived: return static_cast<Derived*>(obj)->calc();
      default: terminate(__type_id__Base, "__call_virtual__calc");
      }
   }

    /* virtual */ int calc() { return 0; }
};

class Derived : public Base {
    /* virtual */ int calc() { return Base::calc() + 1; }
};

...
Base * base = getObj();
return Base::__call_virtual__calc(base);

>Динамический язык тут не катит. виртуальный вызов — это тоже вызов кода по динамическому указателю

...
switch(ch) {
  case "Run":
      slots["Run"]->callThisTwoArgs(self,arg1, arg2);
}
..

К>>Строковые ли, числовые ли — не важно. Числа, опять же, линкер может раздавать

@goto_indirect:
  cmp %reg1000%, ID_Function1
  jmp_eq @Function1
  cmp %reg1000%, ID_Function2
  jmp_eq @Function2
  ...

CALL_INDIRECT Function2

mov %reg1000%, ID_Function2
push %IP%+4
jmp @goto_indirect

К>mov %reg1000%, ID_Function2
К>push %IP%+4
К>jmp @goto_indirect
К>

push %pointer%
ret

дофига кода
of(примитив 1) {
   код для примитив 1
}

of(примитив 2) {
   код для примитив 2
}

of(примитив 3) {
   код для примитив 3
}

ещё дофига кода

Syntax

// direct call to named function, func is a symbol
call{.uni} (ret-param), func, (param-list);
call{.uni} func, (param-list);
call{.uni} func;

// indirect call via pointer, with full list of call targets
call{.uni} (ret-param), fptr, (param-list), flist;
call{.uni} fptr, (param-list), flist;
call{.uni} fptr, flist;

// indirect call via pointer, with no knowledge of call targets
call{.uni} (ret-param), fptr, (param-list), fproto;
call{.uni} fptr, (param-list), fproto;
call{.uni} fptr, fproto;