💞 😉 🙍🏼 编程语言Ü。简介，创造动力，目标 💪🏻 💇 🐕

引言

自2016年以来（间断），我一直在开发自己的编程语言。该语言的名称为“Ü”。为什么是Ü？因为我想要一个字母名称，所以AZ集中的所有字母都已被使用。

本文的任务是使公众熟悉这种语言，以便对其进行总体了解。本文无意完整描述语言，如有必要，将在后续文章中提供对该语言的更完整描述。

为什么我们需要另一种语言？

我检查了一些现有的或多或少知名的静态类型编译语言，得出的结论是它们都不完全适合我。它们都具有“致命的”缺陷。

具体要点：

C-水平太低且不安全
C ++-继承了许多低级缺陷，用脚射击自己的新方法，缺乏反思
D-垃圾收集器，单独的引用类型
Java是垃圾回收器，所有复合类型均被引用，并牢固地附加到虚拟机上。这很多也适用于基于JVM的语言。
C＃-缺陷很像Java
Rust-需要明确地采用链接并明确地取消引用它们，（以主观方式）当一切都是表达式并返回结果时存在方法的危险，存在对协议遵从的明确指示，缺乏继承
开始-垃圾收集器，缺少模板
Swift-参考类型，需要明确指出是否符合协议

在发现上述所有语言的缺陷之后，我决定创建自己的语言，而在我看来，它没有所有缺陷。

一般资讯

Ü是具有强类型的编译型静态类型语言。该语言包含自由函数，结构，类，结构和类的方法。现有类型的类型-基本的，结构的（结构，类），恒定大小的数组，元组，枚举，函数指针。类可以参与继承并具有虚函数。该语言支持模板，其中包含用于类和结构的模板，类型，函数和方法的别名。函数和运算符有很多重载（有一些限制）。

该语言支持类和结构的析构函数。析构函数用于管理资源，包括内存。

已经有什么了

实现了基于LLVM的编译器。编译器支持所有支持LLVM的平台。编译器尚不知道如何创建纯可执行文件，但是它可以生成目标文件，汇编代码，二进制或文本llvm代码。可以与C代码进行通信，有一个实用程序可以更轻松地为C库编写Ü-header。

目的和目的

语言的创建方式可以在编译阶段捕获最大数量的典型错误。语言设计的决定主要基于此任务。第二个目标是（相对）易于编写程序和易于读取程序。

该语言不包含可能引起错误代码编写的构造，也不包含可能会使对程序中发生的事情的理解明显复杂化的功能。

尽管有上述几点，但性能问题不容忽视。因此，不利于性能，没有做出语言设计决策。

因此，让我们看看Ü中与既定目标相对应的时刻。

类型系统

与C ++不同，在Ü中没有指针和引用作为类型。根本没有指针，只有链接，而只是堆栈链接，函数引用参数，引用字段。另外，mut / imut修饰符也不是类型的一部分，而是变量，引用，函数参数，字段的一部分。

由于这种简化，对类型在哪里有了更深入的了解，尤其是在样板代码中。毫无疑问，是否将声明链接或变量，由于typeof（来自C ++的decltype的模拟）而引起的疑问，对常数/非常数的疑问。

这种简化的另一面是需要对模板中的一致性和链接进行单独处理。但是，当将constancy参数作为显式独立的参数传递给模板时，这会增加清晰度。

初始化器

声明变量并不对其进行初始化是不可能的。声明的变量的任何字节都必须初始化。

基本（和其他一些）类型需要强制初始化：

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++.

, , , .

, , . , , , . , - , .

→

→ , , .

→ .

, . . , .

编程语言Ü。 简介，创造动力，目标

引言

一般资讯

已经有什么了

目的和目的

类型系统

初始化器

More articles:

编程语言Ü。简介，创造动力，目标