Cześć,
Tym razem temat nie dotyczy AI. Chciałem się podzielić takim małym odkryciem. Myślę, że da się skonstruować bardzo silny język w którym byłyby tylko definicje typów, deklaracje zmiennych, instrukcje przypisania i specjalna instrukcja “execute”. Nie jestem pewien, czy byłby lepszy od np. C++ (który bardzo lubię), ale na pewno byłby bardziej minimalistyczny. Ten pomysł spodobał mi się tak bardzo, że aż zacząłem implementować interpreter tego języka. To tylko eksperyment, ale może ktoś zechce o tym podyskutować.
Przykład1 – brak funkcji.
Istnieje specjalny wbudowany typ “code”. Literały tego typu mają postać ciągu poleceń zamkniętych w nawiasach klamrowych. Zmienne mogą być typu “code”.
variable x:code; # to jest deklaracja zmiennej x typu code
let variable x = value { execute print “hello world\n”; }
execute variable x;
Przykład2 – brak pętli.
Zamiast iterować po typie wyliczeniowym można zadeklarować typ a potem rodzinę zmiennych:
type person={Gotrek, Gerrudir, Gwaigilion};
let variable introduce_(X:person) = value { execute print “hello, I am “ (X:person) };
execute variable introduce_(X:person); # tutaj wykonujemy implicite pętlę po typie person
Przykład3 – brak wyrażeń i instrukcji warunkowej.
Zamiast pisać if (wyrażenie) { blok; } postępujemy inaczej – definiujemy rodzinę zmiennych typu code, następnie przypisujemy dwóm różnym zmiennym z tej rodziny kod, który ma być wykonany w alternatywnych przypadkach:
type boolean={false, true};
variable x:boolean;
variable if_x_print_message (V:boolean): code;
let variable if_x_print_message true = value { execute print “x is true\n”; };
let variable if_x_print_message false = value { execute print “x is false\n”; };
...
let x=value true;
...
execute variable if_x_print_message <x>; # operator <> zwraca wartość zmiennej
Przykład4 – polimorfizm bez klas i dziedziczenia.
type person={Gotrek, Gerrudir, Gwaigilion};
let variable introduce_(X:person) = value { execute print “hello, I am “ (X:person) };
let variable introduce_Gotrek = value { execute print “hi there, me I am Gotrek”; };
execute variable introduce_(X:person); # tutaj wykonujemy implicite pętlę po typie person
# ale Gotrek wykona inny kod
Przykład5 – brak parametrów funkcji.
Zamiast parametrów funkcji przypisujemy rodzinie zmiennych pewien kod który zależy od tzw. placeholderów (w tym wypadku X i Y):
type person={Gotrek, Gerrudir, Gwaigilion};
variable check_whether_(X:person)_likes_(Y:person): code;
let variable check_whether_(X:person)_likes_(Y:person) =
value {
execute print (X:person) “ likes “ (Y:person) “:”;
execute if_x_print_message <(X:person)_likes_(Y:person)> ;
};
execute variable check_whether_(X:person)_likes_(Y:person);
Przykład6 – brak stosu i zwracania wartości przez funkcje.
Zamiast funkcji zwracającej wartość mamy kod, który przypisuje wartość zmiennej w bloku, który go wywołuje.
variable my_result: boolean;
variable x:code;
let variable x = value { execute print “we return true”; let variable my_result = value true; };
execute variable x;
Innymi słowy mielibyśmy język w którym nie istniałyby struktury danych, pętle, instrukcje warunkowe, przekazywanie parametrów, klasy, dziedziczenie, alokowanie dynamicznej pamięci itd. A mimo to byłby być może równie silny jak zwykłe języki. Co o tym myślicie?
Uruchamia kod warunkowo, więc wygląda na całkiem przyzwoitą instrukcję warunkową!
).