प्रोग्रामिंग भाषा Ü। परिचय, बनाने की प्रेरणा, लक्ष्य

परिचय

2016 से (रुकावट के साथ) मैं अपनी खुद की प्रोग्रामिंग भाषा विकसित कर रहा हूं। इस भाषा का नाम “is” है। क्यों Ü क्योंकि मुझे एक-अक्षर का नाम चाहिए था, और AZ के सेट से सभी पत्र पहले ही ले लिए गए हैं।

इस लेख में इस भाषा के साथ जनता को परिचित कराने का काम है, इसका एक सामान्य विचार देना। लेख का पूरी तरह से भाषा का वर्णन करने का इरादा नहीं है, यदि आवश्यक हो, तो भाषा का अधिक पूर्ण विवरण, बाद के लेखों में दिया जाएगा।

हमें दूसरी भाषा की आवश्यकता क्यों है?

मैंने कई प्रकार की मौजूदा संकलित भाषाओं की कम या ज्यादा जानी-मानी भाषाओं की जांच की, और इस निष्कर्ष पर पहुंचा कि उनमें से कोई भी मुझे पूरी तरह से सूट नहीं करता है। उन सभी में "घातक" दोष हैं।

विशिष्ट बिंदु:

• सी - बहुत कम स्तर और असुरक्षित
• सी ++ - कई निम्न-स्तरीय दोषों को विरासत में मिला, पैर में खुद को गोली मारने के नए तरीके, प्रतिबिंब की कमी
• डी - कचरा कलेक्टर, अलग-अलग संदर्भ प्रकार
• जावा एक कचरा संग्राहक है, सभी मिश्रित प्रकारों को संदर्भित किया जाता है, एक आभासी मशीन के लिए मजबूत लगाव। इसका बहुत सा हिस्सा JVM- आधारित भाषाओं पर भी लागू होता है।
• C # - दोष जावा की तरह हैं
• जंग - स्पष्ट रूप से लिंक लेने की आवश्यकता है और स्पष्ट रूप से उन्हें रोकना, (विषयवस्तु) एक दृष्टिकोण का खतरा जब सब कुछ एक अभिव्यक्ति है और परिणाम देता है, प्रोटोकॉल के अनुपालन का एक स्पष्ट संकेत की उपस्थिति, विरासत की कमी
• गो - कचरा संग्रहकर्ता, टेम्पलेट्स की कमी
• स्विफ्ट - संदर्भ प्रकार, प्रोटोकॉल के अनुपालन को स्पष्ट रूप से इंगित करने की आवश्यकता है

उपरोक्त सभी भाषाओं की अपूर्णता का पता लगाने के बाद, मैंने अपना खुद का, इससे रहित, जैसा कि मुझे लगता है, सभी दोषों को बनाने का फैसला किया।

सामान्य जानकारी

Iled मजबूत टाइपिंग के साथ एक संकलित, सांख्यिकीय रूप से टाइप की गई भाषा है। भाषा में नि: शुल्क कार्य, संरचनाएं, कक्षाएं, संरचनाएं और कक्षाएं शामिल हैं। मौजूदा प्रकार के प्रकार - मौलिक, संरचनात्मक (संरचनाएं, वर्ग), निरंतर आकार के सरणियों, ट्यूपल्स, गणना, कार्यों के लिए संकेत। कक्षाएं विरासत में भाग ले सकती हैं और आभासी कार्य कर सकती हैं। भाषा टेम्पलेट्स का समर्थन करती है, वर्गों और संरचनाओं, प्रकारों, कार्यों और विधियों के उपनामों के लिए टेम्पलेट हैं। कार्यों और ऑपरेटरों का एक अधिभार है (कुछ प्रतिबंधों के साथ)।

भाषा कक्षाओं और संरचनाओं के लिए विनाशकों का समर्थन करती है। विनाशकारियों का उपयोग संसाधनों को प्रबंधित करने के लिए किया जाता है, जिसमें मेमोरी शामिल है।

पहले से क्या है

लागू एलएलवीएम आधारित संकलक। संकलक सभी प्लेटफार्मों का समर्थन करता है जो एलएलवीएम का समर्थन करता है। कंपाइलर अभी तक पूरी तरह से निष्पादन योग्य फ़ाइलों को बनाने का तरीका नहीं जानता है, लेकिन यह ऑब्जेक्ट फ़ाइलें, कोडांतरक कोड, बाइनरी या टेक्स्ट llvm कोड उत्पन्न कर सकता है। सी कोड के साथ संवाद करना संभव है, एक उपयोगिता है जो सी पुस्तकालयों के लिए to-हेडर लिखना आसान बनाती है।

लक्ष्य और उद्देश्य

भाषा को इस तरह बनाया गया है कि संकलन की अवस्था में अधिकतम संख्या में विशिष्ट त्रुटियों को पकड़ा जा सके। भाषा डिजाइन पर निर्णय मुख्य रूप से इस कार्य के आधार पर किए जाते हैं। दूसरा लक्ष्य है (रिश्तेदार) कार्यक्रमों को लिखने में आसानी और उन्हें पढ़ने में आसानी।

भाषा में ऐसे निर्माण शामिल नहीं हैं जो गलत कोड के लेखन को उत्तेजित कर सकते हैं, और उन विशेषताओं को भी शामिल नहीं करते हैं जो कार्यक्रम में होने वाली समझ को महत्वपूर्ण रूप से जटिल कर सकते हैं।

उपरोक्त बिंदुओं के बावजूद, प्रदर्शन के मुद्दे को नजरअंदाज नहीं किया जा सकता है। इसलिए, प्रदर्शन की रुकावट के लिए, भाषा डिजाइन निर्णय नहीं किए जाते हैं।

तो, आइए देखें कि let's में कौन से क्षण हैं जो उल्लिखित लक्ष्यों के अनुरूप हैं।

प्रकार प्रणाली

C ++ के विपरीत, Ü में कोई बिंदु और संदर्भ प्रकार के रूप में नहीं हैं। कोई संकेत नहीं हैं, लिंक हैं, लेकिन केवल स्टैक लिंक, फ़ंक्शन संदर्भ तर्क, संदर्भ फ़ील्ड के रूप में। इसके अलावा, mut / imut संशोधक एक प्रकार का हिस्सा नहीं हैं, लेकिन एक चर, संदर्भ, फ़ंक्शन तर्क, फ़ील्ड का हिस्सा हैं।

इस सरलीकरण के लिए धन्यवाद, इस बात की अधिक समझ है कि किस प्रकार का है, विशेष रूप से बॉयलरप्लेट कोड में। इसमें कोई संदेह नहीं है कि क्या लिंक या चर घोषित किया जाएगा, टाइपोफ के परिणामस्वरूप संदेह (सी ++ से डिक्लेपट का एनालॉग), निरंतर / गैर-निरंतर के बारे में संदेह।

इस सरलीकरण का दूसरा पहलू टेम्पलेट में स्थिरता और लिंक के अलग-अलग प्रसंस्करण की आवश्यकता है। हालाँकि, यह स्पष्टता जोड़ता है जब एक स्पष्ट रूप से अलग तर्क के रूप में टेम्पलेट के लिए गतिरोध पैरामीटर पारित किया जाता है।

initializers

एक चर घोषित करना असंभव है और इसे प्रारंभ नहीं करना है। घोषित चर के किसी भी बाइट को आरंभीकृत किया जाना चाहिए।

मौलिक (और कुछ अन्य) प्रकारों को अनिवार्य आरंभ की आवश्यकता होती है:

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

, , , .

, , . , , , . , - , .

→

→ , , .

→ .

, . . , .