Geekly articles weekly

Bahasa pemrograman Ü. Pendahuluan, motivasi untuk menciptakan, tujuan

Pendahuluan


Sejak 2016 (dengan interupsi) saya telah mengembangkan bahasa pemrograman saya sendiri. Nama bahasa ini adalah "Ü". Kenapa begitu? Karena saya ingin nama satu huruf, dan semua huruf dari himpunan AZ sudah diambil.

Artikel ini memiliki tugas untuk membiasakan masyarakat dengan bahasa ini, untuk memberikan gambaran umum tentangnya. Artikel tersebut tidak bermaksud untuk mendeskripsikan bahasa sepenuhnya, deskripsi bahasa yang lebih lengkap, jika perlu, akan diberikan dalam artikel selanjutnya.

Mengapa kita perlu bahasa lain?

Saya memeriksa sejumlah yang diketik secara statis dikompilasi lebih atau kurang terkenal bahasa, dan sampai pada kesimpulan bahwa tidak ada yang sepenuhnya cocok untuk saya. Semuanya memiliki kekurangan "fatal".

Poin spesifik:

  • C - level terlalu rendah dan tidak aman
  • C ++ - mewarisi banyak kekurangan level rendah, cara baru menembak diri sendiri, kurang refleksi
  • D - pengumpul sampah, tipe referensi terpisah
  • Java adalah pengumpul sampah, semua tipe komposit direferensikan, lampiran kuat ke mesin virtual. Banyak dari ini juga berlaku untuk bahasa berbasis JVM.
  • C # - kekurangannya mirip dengan Java
  • Karat - kebutuhan untuk secara eksplisit mengambil tautan dan secara dereferensikan mereka, (secara subyektif) bahaya dari suatu pendekatan ketika semuanya merupakan ekspresi dan mengembalikan suatu hasil, kehadiran indikasi eksplisit kepatuhan terhadap protokol, kurangnya pewarisan
  • Pergi - pengumpul sampah, kekurangan template
  • Jenis referensi cepat, kebutuhan untuk secara eksplisit menunjukkan kepatuhan dengan protokol

Setelah menemukan ketidaksempurnaan semua bahasa di atas, saya memutuskan untuk membuat bahasa saya sendiri, tanpa, seperti kelihatannya, semua kekurangan.

Informasi umum


Ü adalah bahasa yang dikompilasi, diketik secara statis dengan pengetikan yang kuat. Bahasa mengandung fungsi bebas, struktur, kelas, metode untuk struktur dan kelas. Jenis tipe yang ada - fundamental, struktural (struktur, kelas), array ukuran konstan, tupel, enumerasi, petunjuk ke fungsi. Kelas dapat berpartisipasi dalam warisan dan memiliki fungsi virtual. Bahasa ini mendukung templat, ada templat untuk kelas dan struktur, alias tipe, fungsi, dan metode. Ada kelebihan fungsi dan operator (dengan beberapa batasan).

Bahasa ini mendukung destruktor untuk kelas dan struktur. Destructors digunakan untuk mengelola sumber daya, termasuk memori.

Apa yang sudah ada di sana


Diimplementasikan kompiler berbasis LLVM. Kompiler mendukung semua platform yang mendukung LLVM. Kompiler belum tahu cara membuat file yang murni dapat dieksekusi, tetapi dapat menghasilkan file objek, kode assembler, kode biner atau teks llvm. Dimungkinkan untuk berkomunikasi dengan kode C, ada utilitas yang membuatnya lebih mudah untuk menulis header-Ü untuk perpustakaan C.

Tujuan dan sasaran


Bahasa dibuat sedemikian rupa untuk menangkap jumlah maksimum kesalahan tipikal pada tahap kompilasi. Keputusan tentang desain bahasa dibuat terutama berdasarkan tugas ini. Tujuan kedua adalah kemudahan (relatif) menulis program dan kemudahan membacanya.

Bahasa tidak mengandung konstruksi yang dapat memicu penulisan kode yang salah, dan juga tidak mengandung fitur yang secara signifikan dapat mempersulit pemahaman tentang apa yang terjadi dalam program.

Terlepas dari poin-poin di atas, masalah kinerja tidak dapat diabaikan. Oleh karena itu, untuk merugikan kinerja, keputusan desain bahasa tidak dibuat.

Jadi, mari kita lihat momen apa yang ada di Ü yang sesuai dengan tujuan yang dinyatakan.

Jenis sistem


Tidak seperti C ++, di Ü tidak ada pointer dan referensi sebagai tipe. Tidak ada pointer sama sekali, ada tautan, tetapi hanya sebagai tautan tumpukan, argumen referensi fungsi, bidang referensi. Juga, pengubah mut / imut bukan bagian dari tipe, tetapi merupakan bagian dari variabel, referensi, argumen fungsi, bidang.

Berkat penyederhanaan ini, pemahaman di mana jenis apa yang ditingkatkan, terutama dalam kode boilerplate. Tidak ada keraguan apakah suatu tautan atau variabel akan dideklarasikan, keraguan sebagai hasil dari typeof (analog dari jenis pernyataan dari C ++), keraguan tentang konstan / tidak-konstan.

Sisi lain dari penyederhanaan ini adalah perlunya pemrosesan konsistensi dan tautan yang terpisah dalam templat. Meskipun, ini menambah kejelasan ketika parameter konstancy dilewatkan ke template sebagai argumen terpisah yang eksplisit.

Inisialisasi


Tidak mungkin untuk mendeklarasikan variabel dan tidak menginisialisasi itu. Setiap byte dari variabel yang dideklarasikan harus diinisialisasi.

Jenis fundamental (dan beberapa lainnya) memerlukan inisialisasi wajib:

var i32 x= 22, y(12345);

:

struct Vec{ f32 x; f32 y; }
...
var Vec v{ .x= -56.1f, .y= 42.0f };
var Vec v_uninit; //

, :

struct Vec
{
	f32 x; f32 y;
	fn constructor()
	( x= 0.0f, y= 0.0f )
	{}
}
...
var Vec v; //

, .

, :

struct Vec
{
	f32 x= 0.0f;
	f32 y= 0.0f;
}

, [] , :

var [ i32, 4 ] a[ 1, 1, 3, 4 ];
var tup[ i32, f32 ] t[ 8, 0.5f ];
var [ f32, 16 ] a_uninit; // ,     .
var[ i32, 3 ] aa[ 0, 1 ]; // ,

C++, , . , , — .

. , , — . this, - /, :

struct Vec
{
	f32 x; f32 y;
	fn constructor()
	( x= y, y= 0.0f ) // ,  «y»   
	{}

	fn constructor( f32 val )
	( x= val, y= x ) // . «x»         «y»
	{}
}


. , , . .

:

var i32 mut x= 0;
var i32 &mut ref0= x;
++x; // ,        
var i32 &imut ref1= x; // ,    , . .

:

var i32 mut x= 0;
var i32 &imut ref0= x;
var i32 &mut ref1= x; // ,    ,

:

var i32 mut x= 0;
var i32 &mut ref0= x;
var i32 &mut ref1= ref0; //  , . .       ,

:

fn Mutate( i32 &mut x, i32 &mut y );
...
var i32 mut x= 0;
Mutate( x, x ); // ,

. C++

std::vector<int> vec;
vec.push_back(1);
int& ref= vec.front();
vec.push_back(2); // ,  ref

Ü :

var ust::vector</i32/> mut vec;
vec.push_back(1);
var i32 &imut ref= vec.front();
vec.push_back(2); // ,      vec,


( ). — polymorph, interface, abstract . . , .

:

  • . , , .

    :

    class A interface
{
	fn virtual pure Foo(this);
}
  • . . . , this, , . . . abstract call, , , C++.

    :

    class A abstract
{
	fn virtual pure Foo(this);
	fn virtual Bar(this){}
	i32 x= 0;
}
  • . . . - , .

    :

    class A interface
{
	fn virtual pure Foo(this);
}
class B : A
{
	fn virtual override Foo(this){}
}
  • . , , .

. .

fn virtual pure Foo(this); //    .      ,        ,   .

fn virtual Foo(this){} //     .   ,      .

fn virtual override Foo(ths){} //   ,    .         ,   .

fn virtual final Foo(this){} //   ,     .         ,   .  -    ,   .


2019— , , Ü . . , , , , .

:

fn Foo( i32 mut x ) : i32
{
	while(x  < 100 )
	{
		x+= 10;
		continue;
		x+= 20; // ,  
	}
	return x;
	++x; // ,  
}

:

fn Foo( i32 x ) : i32
{
	if( x < 10 ) { return 0; }
	else if( x > 100 ) { return 1; }
	// ,     
}

else , return .

, - , halt ( ). , , , return.


. , (. ). () .

:

struct CallableObject
{
	i32 &mut x;
	op()( mut this )
	{
		++x;
	}
}
...
var i32 mut x= 0;
var CallableObject mut obj{ .x= x };
auto thread= ust::thread_create( move(obj) );
++x; // ,   «x»,        «thread»
++ obj.x; //

- , , - , .

(mutable C++), . . . , - , .

, ? — shared_ptr_mt . , , lock_mut() lock_imut(), . « , ».

:

struct Incrementer
{
	ust::shared_ptr_mt_mut</ i32 /> ptr;
	op()( mut this )
	{
		auto mut lock= ptr.lock_mut(); //   «lock»  
		++lock.get_ref();
	}
}
...
var ust::shared_ptr_mt_mut</ i32 /> ptr(0);
var size_type mut i(0);
var ust::vector</ ust::thread</Incrementer/> /> mut threads;
while( i < size_type(64) )
{
	var Incrementer incrementer{ .ptr= ptr };
	threads.push_back( ust::thread_create(incrementer) );
	++i;
}
threads.clear(); //      .
halt if( ptr.lock_imut().get_ref() != 64 ); // ,   ,

, , . . «shared». , , , - , «shared».


. , , constexpr . , .

, Ü, - , C.


C++, (=, +=, *= . .) , , . ++ –.

:

if( x = 0 ) {}
x++; //     ++
x += x += x; // ,  +=  
x+= x++ + ++x; //

. void, .

, , . :

auto a = select( condition ? x : y );

select .


. . . .

? , - :

  • . - , , .
  • . . - NullPointerException - , - . , , . . .
  • . , , , . - - , . , .
  • . , , .

, , ?

, . . «» , , std::optional/std::variant C++ Option/Result Rust.

, -, , halt. ( Ü ) , , , .


, - . , import, , . C++, , .

. , *.cpp *.hpp C++.


, , , .

, , . , , , . , - , .


→

→ , , .

→ .

, . . , .

Source: https://habr.com/ru/post/id465553/

More articles:


All Articles