type variant 
{
 | int
   {
     func asInt()
   }
  | string
    {
      func asString()
    }
  | time
    {
      func asTime()
    }
}

mut a:Variant;

if()
{
  a = 1;
}
else
{
  a = "eddd";
}

a.asInt()    // Корректно
a.asString() // Корректно
a.asTime()   // Ошибка состояния типа asTime не доступен

возможно такое?

Здравствуйте, s22, Вы писали:

s22>возможно такое?

Можно все что не противоречит законам природы.

А вот чтобы понять не противоречат ли твои желания оным нужно понять, что ты тут понаписал и что ты под этим имел.

Опиши семантику твоего примера. Когда ошибка в рантайме или во время компиляции? Т.е. динамическая типизация или статическая?

Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, s22, Вы писали:

s22>>возможно такое?

VD>Можно все что не противоречит законам природы.

VD>А вот чтобы понять не противоречат ли твои желания оным нужно понять, что ты тут понаписал и что ты под этим имел.

VD>Опиши семантику твоего примера. Когда ошибка в рантайме или во время компиляции? Т.е. динамическая типизация или статическая?

во время вывода типов (компиляции)

Здравствуйте, VladD2, Вы писали:


примерное описание

переменная имеет поля времени компиляции

class A
{
 a:int;
 comp a:int; // данное поле существует только при компиляции
}


mut a:A;
 
func f(a:A) where a.b=1 or a.b=3
{
}

{
    mut a:A;
    a.b=2;
    f(a) // ошибка
}

{
    mut a:A;
    f(a) // ошибка
}

{
    mut a:A;
        a.b=1;
    f(a) // успешно
}

{
    mut a:A;
    a.b=1
    f(a) // успешно
    a.b=3
    f(a) // успешно
    a.b=2
    f(a) // ошибка компиляции

}

Здравствуйте, s22, Вы писали:

s22>class A
s22>{
s22> a:int;
s22> comp a:int; // данное поле существует только при компиляции
s22>}
s22>    mut a:A;
s22>    a.b=2;
s22>    f(a) // ошибка
s22>}
s22>

Сделать то подобное можно. Но только какой в этом смысл? Ты сможешь пользоваться только константами. Если данные придут извне, то проверки времени компиляции будут невозможны.

Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, s22, Вы писали:

VD>Сделать то подобное можно. Но только какой в этом смысл? Ты сможешь пользоваться только константами. Если данные придут извне, то проверки времени компиляции будут невозможн
Если не возможно определить значение, то выдавать ошибку компиляции...
И не только константы, но и выражения....

Здравствуйте, s22, Вы писали:

s22>Если не возможно определить значение, то выдавать ошибку компиляции...
s22>И не только константы, но и выражения....

Пойми, такой язык будет чем-то вроде калькулятора. Он сможет вычислять (сворачивать) только выражения данные в которых доступны во время компиляции. С файлами, клавиатурой, сетью твой язык работать не сможет.

Какой в нем смысл?

Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, s22, Вы писали:

s22>>Если не возможно определить значение, то выдавать ошибку компиляции...
s22>>И не только константы, но и выражения....

VD>Пойми, такой язык будет чем-то вроде калькулятора. Он сможет вычислять (сворачивать) только выражения данные в которых доступны во время компиляции. С файлами, клавиатурой, сетью твой язык работать не сможет.

VD>Какой в нем смысл?

type into=
{
 vl:int?;
 comp isint:bool;
 comp isnil:bool;
 assign (v:int)
{
 vl=v;
 isint=true;
 isnil=false;
}
 assign (nil)
{
 vl=v;
 isint=false;
 isnil=true;
}

use :int
{
if(isnul) 
Error("ошибка, может быть nil")
if(!isint) 
Error("ошибка, не число")
}

use :nil
{
if(isint)
Error("ошибка, может быть число")
if(!isnil) 
Error("ошибка, не nil")
}

 assign (nil)
{
 vl=v;
 isint=false;
 isnil=true;
}

unionbranch(v:[into])
{
(isint, isnil)=fold([false,false],((initisint, initisnul),(v.isint, v.isnil)) => (initisint||v.isint, initisnul||v.isnil))
}

}

func f(a:int)
{
}
func f1(a:into)
{
}
func f2(a:int?)
{
}
func f3(nil)
{
}


mut a:into;

a=1;

f(a) // норма
f1(a) // норма
f2(a) // норма
f3(a) // ошибка 
if (.....)
a=1 else a=nil;

f(a) // ошибка 
f1(a) // норма
f2(a) // норма
f3(a) // ошибка