Wir schlagen eine neue Sprache vor, die Schildsprache (Schildsprache).
ex.shie
#Dies ist ein Kommentar.
(*Dies ist auch ein Kommentar.*)
#Kommt mit einem Compiler von~ using *Der Namespace kann mit weggelassen werden
from system using * #exit(Das Ende des Programms),TapKey(Tasteneingabe),type(Schimmel),Rtype(制限Schimmel)Eine solche
using os #id(Adressausgabe),exit(Ende) ptr(Zeigerbetrieb)Eine solche
using rapt #Standard-Komfortfunktion
from console using * #print,read,error,linef(Funktion beenden)Eine solche
using err # comment,Debug usw.
from collection using * #Array<>,List<>,Dict<>,range()etc
#Der Dateivorgang verwendet eine Datei
#Externe Datei wird importiert Dieses Mal wird OpenCV importiert.
import cv
rect = rapt.rect #Die Namespace-Rapt-Klasse rect ist auf rect gesetzt
using texisnone as rapt.texture.isnone #def rapt.textureisnone(bool)()Wird ein Alias gegeben.
var n1 = 5
var s1 = "string1"
any d = 5 #Dynamischer Typ
d = "Ah"
#Substitution ist"=",Vergleich ist"=="
var str s2 = "string2"
opt var str s3 = None #Der Referenztyp ist Keine
opt var float n2 = Null #Der Werttyp ist Null
var lst = new [1,"ABC",3.141592] #list ist ein Referenztyp und ein von obj abgeleiteter Typ. Sobald der Typ festgelegt ist, ändert er sich nicht mehr.
lst[1] = 3 #Kompilierungsfehler
lst += 4 #Fügen Sie 3 am Ende der Liste hinzu
print(lst[3]) #output 4
nlst = lst + 8.3 #lst und dann 8.Erstellen Sie nlst mit 3 hinzugefügt
# var lsta = new List<int>[3]{1,2,3}<-Liste, die nur bestimmte Typen enthalten kann
# var lsta = new List<new List<int>>[3,3]{{1,2,3}{4,5,6}{7,8,9}}
var arr = Array<str>[3]{"1","ABC","3.141592"} #Array ist ein Werttyp
var tupple = new (1,"ABC",3.14159265358979)
#var tupple := new {1,"ABC",3.14159265358979}Kann aber deklariert werden
var dic = new Dict<Tupple<str,int>>[2]{("Ah",1),("Ueo",2)}
#Wenn es const ist, kann eine Konstante deklariert werden. Binden, wenn const(:=)verwenden
const Anum := 5
var Aiu[Anum] = Array<int>{1,2,3,4,5}
tupple[2] =3.14 #Kompilierungsfehler
var str Moji = '1' + '3'
print(Moji) #output "13"
var errs1 = '1' + 3 #Kompilierungsfehler:Schimmel ist nicht sicher(str + int)
var MRC_OK = int('1') + int('3')
print(str(MRC_OK)) #output '4'
#Haupttyp Bool,str,int,var,byte,float,obj,ref~,Enum-Derivat,Struktur abgeleiteter Typ,klassenabgeleiteter Typ,Generika-Typ
if(type(n1) is int or opt int):#true
print(f"{n1}")
s1 = switch(s1) case "2" case "3" as "s1 ist"+s1+"ist" break case "string1" case "string2" default as "s1 ist2ではありません" break
print(f"{s1}") #output "s1 ist nicht 2"
enum VakKey:#Nur ein Teil
LEFT = 0x25
RIGHT
UP
DOWN
a = 0x41
b
c
d
var vk[] = new VakKey()<-Erstellen Sie eine Box, die alle Zustände kennt
using val as vk,using VakKey: #Wenn Sie wissen möchten, ob das Innere der Schalterklammer wahr ist, anstelle des Rückgabewerts mit val as~Verwenden Sie die Syntax. Verwenden Sie zu diesem Zeitpunkt weiterhin.
switch(system.TapKey(int(val))):
case .RIGHT as #Folgendes wird ausgeführt:
print("Right")
continue
case .LEFT as
print("Left")
continue
case .UP as
print("Up")
continue
case .DOWN as
print("Down")
continue
#Der Konstruktor der Struktur ist var struct tag name=Strukturname(Konstruktorargument)
struct tanf: #Struktur ist Werttyp(self,Leeres Objekt:Null)
pub unsafe def _init(var int m,var str w,var x) without self: #Für den Konstruktor ist kein Rückgabewert erforderlich
.m = m #Innen ohne.~Kann geschrieben werden.
.w = w
.x = global s1 #Verwenden Sie unsicher, wenn Sie globale Variablen, Variablen der Extraklasse und Zeiger verwenden.
return self
pub def show()():#()Kann weggelassen werden, wenn der Rückgabetyp void return None ist
read (f"{self.m}")
for(i in range(self.m)):
print(str(i)+"Zeit")
print(f"{self.w}Aber{self.x}ist")
pass
pub set(val) pub get var int m #Bereichseinstellung
pub var str w
pub set(val) pub get del var x
dat class Mycdat(obj)(opt var str mydat1,opt var int mydat2)#(Erbe/aspect)(Daten)
dat struct Mysdat(opt var str mydat1,opt var int mydat2)
#Klassenkonstruktor ist var Objektname=neuer Klassenname(Konstruktorargument)
class Myclass(obj):#(Erbe/aspect)Klasse ist ein Referenztypobjekt(this,Leeres Objekt:None)Wenn es sich um eine Basis handelt, können Sie eine Verbindung zur übergeordneten Methode herstellen
pub def _init(int m,ref rect rc,var h,var y,var t[931]):
this.m = m
this.rc = rc
this.h = h
this.y = y
this.t = [if(t[i] is Null) 5 else t[i];for i in range(931)]
pub def show()(int m = 3):
this.m = m
var n = 0
for(not n is this.m and rc is not None):#
print(rc.left,rc.right,rc.top,rc.bottom)
var rect_is_live = if(m < 3) true elif(6 < m and m < 10) false else true
this.rc = if(not rect_is_live) None else pass
pub def show()(var h):
var n = 0
for(not n is this.m and rc is not None):#
print(rc.left,rc.right,rc.top,rc.bottom)
var rect_is_live = if(m < 3) true elif(6 < m and m < 10) false else true
this.rc = if(not rect_is_live) None else pass
pub operator==(bool)(Myclass T): #Überlastung des Bedieners+,-,==,is,and,or,not,xor,*,/,++,--,**,//,%,^,<<,>>,<=,>=,<,>,|,&,!(Die letzten 7 sind Bitoperatoren)Jedoch,,as,=, :=,., ?:, ->, new,Typ kann nicht überladen werden
#+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=,!=Ist durch Überladen des Binäroperators möglich
return (if(not this.m is not T.m) false elif(this.rc is not T.rc) false elif(this.h is not T.h) false elif(this.y is not T.y) false elif(this.t is not T.t) false else true)
set(val) get int m
del opt ref rect rc
var h
var y
ref var t
#Bedingte Generika(Einfache Generika können mit var erstellt werden)
def Tshow<T>()(T t) when T is Rtype(opt ref in(int or str or float)) : #Sie können type anstelle von Rtype verwenden, wir empfehlen es jedoch nicht, da es redundant ist.
opt int s = if(T)
default when:
err.comment("vakerror0001:Keine mit diesem Typ hergestellten Generika")
def sum(var)(var t1,var t2):
return t1 + t2 #Ich erhalte einen Fehler bei der Kompilierung, wenn ich lese, dass die Typen von t1 und t2 zur Kompilierungszeit falsch sind.
#Namensraum(基本はNamensraumに書く今回は特別に外)namespaceとimport名を分けることにより日本語文字列のNamensraumをできるだけ排除しやすいようにする。
namespace ex:
main(opt int)():
return Null
#Ex im Namespace.main()Kann mit zugegriffen werden.(Nach dem Lesen nach unten startet die Hauptfunktion(Wenn es sich außerhalb befindet, wird es zur Kompilierungszeit in die Hauptfunktion eingebunden und befindet sich innerhalb von main)。)
#Aspekt(共通Aspekt)
diversity MyLogging(asp):
def log(int i):
print(f"{i}ist")
Es gibt Boo-Sprache als ähnliche Sprache, aber ich denke, dass sie nicht beliebt war, weil sie der C-Sprache nicht ähnlicher ist als Python. Deshalb habe ich sie als Python erstellt, das mit statischer Typisierung, die wie C, C ++, C # geschrieben werden kann, einfach zu kompilieren ist. Sah. Deshalb habe ich mich auch auf C # und Kotlin bezogen. Das Folgende ist die Version mit Zeigern (Sie können hier auch Makros schreiben). .shie ist in Ordnung, aber ich habe .shiex gewählt, weil die Grammatik etwas anders ist.
ex.shiex
using system;
using os;
using rapt;
using console;
using err;
using collection;
@pragma out_console #out console,only_window,out_window(Die Standardeinstellung ist out_console)
@pragma out_native #out_native out_compile(.jcp) use_jit(JIT-Zusammenstellung/Standard)Kann kombiniert werden
@pragma style Signal_Colon#Es ist möglich, im C-Sprachstil zu schreiben.
#Hauptzeiger
#thisptr->Dies ist ein Referenztyp. thisptr ist ein Zeiger.(Im Namespace OS enthalten)
#ptr,o_ptr->*Wenn ja, kann dies mit Multiplikation verwechselt werden und die Lesbarkeit nimmt ab.(Im Namespace OS enthalten)
#os.id(name)
#Makro
@def MyMacro{
@operator when(tex as when rapt.Texture)#Argumenttyp bedingt#Makrooperator kann die meisten verwenden(Ein leistungsstarkes Makro, mit dem Sie die Struktur selbst ändern können)。
}@as if(tex is not None) true else false;
@def PI = 3.14159265358979 #Konstante(String)Ersetzen
@def TEXT = "ABC"
@def BEGIN @as {
@def END @as }
def unsafe main(opt int)(){
var A[4] = collection.Array<int>{1,2,3,4};
opt int os.ptr s_p = os.id(A);
print(os.o_ptr s_p);#output 1
s_p++;
int s = os.o_ptr s_p;
s_p = os.nullptr;
ref int AA = new {4,5,3,2};
rapt.Texture tx = None;
bool A = MyMacro{when(tx)}
print(A); #output false
if(true) BEGIN ref int BB = AA; END
print(AA[2]); #Kompilierungsfehler
print(BB[2]); #Kompilierungsfehler
print(A[1]); #2
print(s); #output 2
return Null;#Erfolgreiche Fertigstellung
}
Wenn jemand die Technologie hat, um es zu machen, machen Sie es bitte. Was ich über das Schreiben dachte, ist ohne IDE schwer zu schreiben.
Dieser Reformpunkt Aktiviert, um Variablen im Konstruktor mit struct (class) zu deklarieren. Aktiviert, um die Anzahl der Variablen in der Klassenmethode (Referenztyp) zu ändern. Methoden (Defs innerhalb der Klasse) und Prozeduren (Defs außerhalb der Klasse), die außerhalb des Namespace geschrieben wurden, gehören zum Namespace Ihres Dateinamens. Hinzufügen von Schlüsselwörtern ifdef () / eldef () / undef (Variablentyp, Existenz von Variablen) usw. Der Optionstyp (Null, Keine) kann das Schlüsselwort opt weglassen, wenn es zum Zeitpunkt der Zuweisung klar ist. Wenn nichts in var geschrieben ist (numerischer Wert ist veränderlich / Typ ist unveränderlich), const (sowohl Typ als auch numerischer Wert sind unveränderlich), dynamisch (keine Typdeklaration erforderlich / Typ kann geändert werden) (= ist im Grunde var) (),: = ist grundsätzlich const ,; = ist grundsätzlich dynamisch (var im Funktionsaufruf oder if-Anweisung)) Kommt mit einem Compiler using,using ~ as ~,from~ using *,from~ using~ as ~ Von einem Dritten erstellt (ein Programm, das Sie selbst erstellt haben) importieren, importieren ~ als ~, von ~ importieren *, von ~ importieren ~ als ~, von ~ (Dateiname) mit ~ (Namespace) als * (einen bestimmten Namespace in der Datei deaktivieren), von ~ mit ~ as ~ (~ Benenne einen bestimmten Namespace in der Datei um) Von hogehoge mit hugahuga als huga hogehoge.shie Erstellt den Namespace hugahuga huga (hugahuga.Huga-> huga.Huga, hogehoge hugahuga kann nicht verwendet werden). Organisierte Standardeingabe / -ausgabe (Konsolenklasse)
console.shie
print(str) = return None #Zeichenkette kann ausgegeben werden(Nein \ n)Schnell und sicher!
scan() = return (type)str #Zeichenkette kann ausgegeben werden(Nein \ n)Schnell und sicher!
white(type<genelic>) = return None #String,Es kann ein numerischer Wert ausgegeben werden(Nein \ n)CLI-Kalender usw.!
read(type<genelic>) = return (type)str #String,Es kann ein numerischer Wert eingegeben werden(Nein \ n)Wenn Zeilenumbrüche im Weg sind
whiteline(type<genelic>) = return None #String,Es kann ein numerischer Wert ausgegeben werden(¥ n Ja)Ich benutze das normalerweise
readline(type<genelic>) = return (type)str #String,Es kann ein numerischer Wert eingegeben werden(¥ n Ja)Ich benutze das normalerweise
input(type<genelic> or f"",~) = return None #Es kann eine F-Zeichenfolge verwendet werden(¥ n Ja)Wenn Sie die Verwendung der Zeichenfolge f bequem nutzen möchten
output(type<genelic> or f"",~) = return (type)str #Es kann eine F-Zeichenfolge verwendet werden(¥ n Ja)Wenn Sie die Verwendung der Zeichenfolge f bequem nutzen möchten
linef() return '¥n'
(type)str->format()
exp.shie
from system using *
from console using *
from collection using *
#Out-of-Namespace-Prozedur
def sum(var)(var i,var j):
return i+j
#Klasse außerhalb des Namespace
class Main:
pub def main(var int)():
abc = new nan.ABC("Ah",10)
output(for(i in range(abc.get_n())) abc.get_is_Nothing())#output "false" * 10
abc.show(3.14159265358979)#output "3.14159265358979"*10
abc.show(3,4,true) #output true*3 false*4
return Null
namespace nan:
class ABC(obj):
pub def _init(str m,int n) without this:
pub set(val) pub get del var .is_Nothing = if(m is None) true elif(m.isEmpty()) true else false
pub set(val) pub get var .n = n
pub def show()(var K)without this:
pub set(val) get var .K = K
output(for(i in range(.n)) .Ist K.)
pub def operetor== (bool)(ABC abc)without this:
ifdef(.K):
return .isNothig == abc.get_isNothig() and .n == abc.get_n() and .K == abc.k()
undef:
return .isNothig == abc.get_isNothig() and .n == abc.get_n()
#Überlast
pub def show()(int A,int B,bool C):
var bcd = exp.BCD(A,B,C)
bcd.show()
#Out-of-Namespace-Struktur
struct BCD:
pub def _init(int A,int B,bool C) without self:
pub set(val) pub get del var .A = A
.B = B
.C = C
pub def show()()without self:
print(for(a in range(.A))C,for(b in range(.B))not C)