Rustプログラミング言語の概要

Rustは、Mozillaが開発した新しい実験的なプログラミング言語です。 この言語はコンパイルされ、マルチパラダイマティックであり、C / C ++の代替として位置付けられています。これは、それ自体が興味深いものです。 D Walter BrightまたはGoをGoogleから呼び出すことができます。

Rustは、関数型、並列型、手続き型、およびオブジェクト指向プログラミングをサポートしています。 実際に応用プログラミングで使用されるパラダイムのほぼ全範囲。



私はドキュメントを翻訳するつもりはありません（さらに、言語の公式リリースがまだないため、非常に少なく、絶えず変更されています）が、代わりに言語の最も興味深い機能を強調したいです。 情報は、公式文書と、インターネット上の言語への非常に少数の参照から収集されます。

第一印象

この言語の構文は、従来のCのようなスタイルで構築されています（これはすでに事実上の標準であるため、喜ばせざるを得ません）。 当然、よく知られているC / C ++設計エラーが考慮されます。

従来のHello Worldは次のようになります。

use std; fn main(args: [str]) { std::io::println("hello world from " + args[0] + "!"); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

例はもう少し複雑です-階乗計算機能：

 fn fac(n: int) -> int { let result = 1, i = 1; while i <= n { result *= i; i += 1; } ret result; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

例からわかるように、関数は「機能的」スタイルで宣言されています（このスタイルには、従来の「int fac（int n）」よりもいくつかの利点があります）。 自動型推論 （letキーワード）、while引数に括弧がないこと（Goと同様）が見られます。 キーワードのコンパクトさはすぐに明らかになります。 Rustの作成者は、意図的にすべてのキーワードをできる限り短くしており、正直なところ、それが気に入っています。

小さいながらも興味深い構文機能

• アンダースコアは数値定数に挿入できます。 便利なことに、現在この機能は多くの新しい言語に追加されています。
  
  0xffff_ffff_ffff_ffff_ffff_ffff
  
  
  
  
  
  
• 二項定数 もちろん、本物のプログラマは心の中でビンを16進数に変換する必要がありますが、より便利です！ 0b1111_1111_1001_0000
  
  
  
  
• 演算子の本体（単一の式で構成されるものも含む）は、中括弧で囲む必要があります。 たとえば、Cでは、 if(x>0) foo();
  
  
  
  書くことができif(x>0) foo();
  
  
  
  、Rustでは、foo（）を中括弧で囲む必要があります
• ただし、if、whileなどの演算子の引数を括弧で囲む必要はありません
• 多くの場合、コードのブロックは式と見なすことができます。 特に、たとえば、これは可能です：
  
  

   let x = if the_stars_align() { 4 } else if something_else() { 3 } else { 0 };
        
        
  
          
          
          
        
  
      
          
          
          
        
        
  
          
          
          
        
  
      
       

• 関数を宣言するための構文-最初にキーワードfn、次に引数のリスト、名前の後に引数の型が示され、次に関数が値を返す場合、矢印「->」と戻り値の型
• 変数は同じ方法で宣言されます。letキーワード、変数名、変数の後、コロンの後のタイプを指定してから、初期値を割り当てることができます。
  
  let count: int = 5;
  
  
  
  
• デフォルトでは、すべての変数は不変です。 mutableキーワードは、可変変数を宣言するために使用されます。
• 基本型の名前は、私が出会った中で最もコンパクトです：i8、i16、i32、i64、u8、u16、u32、u64、f32、f64
• 上記のように、自動型推論がサポートされています

この言語には、プログラム用の組み込みのデバッグツールがあります。

failキーワードは、現在のプロセスを終了します。

logキーワードは、ログ内の言語表現を表示します（たとえば、stderr）

assertキーワードは式を検証し、falseの場合、現在のプロセスを終了します

キーワードkeywordを使用すると、プロセスが異常終了した場合に追加情報を表示できます。

データ型

RustはGoと同様に、 構造タイピングをサポートします （ただし、著者によると、独自に開発された言語であるため、これは共通の前身であるAlef、Limboなどの影響です）。 構造タイピングとは何ですか？ たとえば、あるファイル（または、Rustの用語では「レコード」）で宣言された構造があります

type point = {x：float、y：float};

引数タイプのポイントを使用して、一連の変数と関数を宣言できます。 次に、他のどこかで、他の構造を宣言できます。例えば

タイプMySuperPoint = {x：float、y：float};

このタイプの変数は、ポイント型の変数と完全に互換性があります。



対照的に、C、C ++、C＃、およびJavaで採用されている主格の類型化では、このような構成は許可されていません。 主格型指定では、各構造は一意の型であり、デフォルトでは他の型と互換性がありません。



Rustの構造は「レコード」と呼ばれます。 タプルもあります-これらは同じレコードですが、名前のないフィールドがあります。 記録要素とは異なり、タプル要素は変更できません。



ベクトルがあります-通常の配列にいくらか似ていて、あるものではstlからの型：stlからのベクトル。 リストを初期化するとき、角括弧が使用され、C / C ++のように中括弧ではありません

 let myvec = [1, 2, 3, 4];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

それにもかかわらず、ベクトルは動的なデータ構造であり、特に、ベクトルは連結をサポートします。

 let v: mutable [int] = [1, 2, 3]; v += [4, 5, 6];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

パターンがあります。 それらの構文は非常に論理的であり、C ++からの「テンプレート」のヒープはありません。 関数テンプレートとデータ型がサポートされています。

 fn for_rev<T>(v: [T], act: block(T)) { let i = std::vec::len(v); while i > 0u { i -= 1u; act(v[i]); } } type circular_buf<T> = {start: uint, end: uint, buf: [mutable T]};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この言語は、いわゆるタグをサポートしています 。 これは、追加フィールド-使用されるオプションのコード（つまり、共用体と列挙型の間で共通するもの）を備えたCの共用体にすぎません。 または、理論的な観点から、代数的データ型。

 tag shape { circle(point, float); rectangle(point, point); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最も単純な場合、タグは列挙と同一です。

 tag animal { dog; cat; } let a: animal = dog; a = cat;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

より複雑な場合、「列挙」の各要素は、独自の「コンストラクタ」を持つ独立した構造です。

もう1つの興味深い例は、「リスト」タイプのオブジェクトが定義されている再帰構造です。

 tag list<T> { nil; cons(T, @list<T>); } let a: list<int> = cons(10, @cons(12, @nil));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タグは、非常に複雑なパターンマッチング式に参加できます。

 alt x { cons(a, @cons(b, _)) { process_pair(a,b); } cons(10, _) { process_ten(); } _ { fail; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

パターンマッチング

まず、マッチングのパターンを改善されたスイッチと見なすことができます。 altキーワードが使用され、続いて分析された式が使用され、次にオペレーターの本体で-パターンと一致した場合のパターンとアクション。

 alt my_number { 0 { std::io::println("zero"); } 1 | 2 { std::io::println("one or two"); } 3 to 10 { std::io::println("three to ten"); } _ { std::io::println("something else"); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「パターン」として、定数（Cなど）だけでなく、変数、タプル、範囲、型、プレースホルダー文字（プレースホルダー、「_」）などのより複雑な式も使用できます。 パターンの直後にあるwhenステートメントを使用して、追加の条件を指定できます。 マッチタイプには特別な演算子オプションがあります。 これは、言語に汎用バリアント型anyがあり 、そのオブジェクトには任意の型の値を含めることができるためです。



ポインター。 通常の「ポインター」ポインターに加えて、Rustは組み込みの参照カウント-共有（共有ボックス）と一意（一意のボックス）を持つ特別な「スマート」ポインターをサポートします。 これらは、C ++のshared_ptrおよびunique_ptrとやや似ています。 これらには独自の構文があります：@は共有、〜は一意です。 一意のポインターの場合、コピーする代わりに特別な操作があります-移動：

 let x = ~10; let y <- x;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このような移動の後、ポインターxは初期化されません。

クロージャ、部分使用、イテレータ

この時点から、関数型プログラミングが始まります。 Rustは高階関数の概念を完全にサポートしています。つまり、引数として他の関数を返すことができる関数です。



1. lambdaキーワードは、ネストされた関数または関数のデータ型を宣言するために使用されます。

 fn make_plus_function(x: int) -> lambda(int) -> int { lambda(y: int) -> int { x + y } } let plus_two = make_plus_function(2); assert plus_two(3) == 5;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例では、int型の1つの引数「x」を取り、「int-> int」型の関数を返すmake_plus_function関数があります（ここでlambdaはキーワードです）。 この関数は、関数の本文で説明されています。 「return」演算子がないことは少しわかりにくいですが、FPの場合、これはよくあることです。



2. blockキーワードを使用して、関数型（関数への引数）を宣言します。これは、通常のコードのブロックのように見えるものに置き換えることができます。

 fn map_int(f: block(int) -> int, vec: [int]) -> [int] { let result = []; for i in vec { result += [f(i)]; } ret result; } map_int({|x| x + 1 }, [1, 2, 3]);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここには、入力がブロックに供給される関数があります-基本的に "int-> int"型のラムダ関数とint型のベクトル（以下のベクトルの構文について）。 呼び出しコード内の「ブロック」自体は、やや珍しい構文{| x | x + 1}。 個人的には、C＃のラムダが好きです。 それは永続的にビット単位のORとして認識されます（ちなみに、これはすべての古い良いsyshny操作のようにRustにも存在します）。



3.部分的な適用とは、この別の関数のいくつかの引数の値を示すことにより、多数の引数を持つ別の関数に基づいて関数を作成することです。 これを行うには、 bindキーワードとプレースホルダー「_」を使用します。

 let daynum = bind std::vec::position(_, ["mo", "tu", "we", "do", "fr", "sa", "su"])
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

わかりやすくするために、次のような単純なラッパーを作成することで、通常のCでこれを実行できることをすぐに説明します。

const char* daynum (int i) { const char *s ={"mo", "tu", "we", "do", "fr", "sa", "su"}; return s[i]; }







しかし、部分的なアプリケーションは手続き型ではなく機能的なスタイルです（ところで、上記の例から、引数なしで関数を取得するために部分的なアプリケーションを作成する方法は明確ではありません）



別の例：add関数は2つのint引数で宣言され、intを返します。 次に、関数型single_param_fnが宣言されます。これは、1つのint引数を持ち、intを返します。 バインドを使用して、2つの関数オブジェクトadd4およびadd5が宣言され、部分的に引数が指定されたadd関数に基づいて構築されます。

 fn add(x: int, y: int) -> int { ret x + y; } type single_param_fn = fn(int) -> int; let add4: single_param_fn = bind add(4, _); let add5: single_param_fn = bind add(_, 5);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

機能オブジェクトは、通常の関数と同様に呼び出すことができます。

 assert (add(4,5) == add4(5)); assert (add(4,5) == add5(4));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

4.純粋な関数と述語

純粋な関数は、副作用のない関数です（純粋な関数以外の関数を呼び出さない関数を含む）。 このような関数は、キーワードpureによって押し出されます。

  pure fn lt_42(x: int) -> bool { ret (x < 42); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

述語はブール型を返す純粋な関数です。 このような関数は、typestateシステム（以下を参照）で使用できます。つまり、さまざまな静的チェックのコンパイル段階で呼び出されます。



構文マクロ

計画された機能ですが、非常に便利です。 Rustでは、まだ初期開発段階にあります。

 std::io::println(#fmt("%s is %d", "the answer", 42));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

printfの式に似ていますが、コンパイル時に実行される式（したがって、すべての引数エラーはコンパイル段階で検出されます）。 残念ながら、構文マクロに関する資料は非常に少なく、それら自体は開発中ですが、 Nemerleマクロのようなものが判明する可能性があります。

ちなみに、同じNemerleとは異なり、＃記号を使用してマクロを構文的に選択する決定は非常に読み書きが容易だと考えています：マクロは関数とは非常に異なるエンティティであり、コード内のどこで関数が呼び出されているかを見ることが重要だと思います-マクロ。

属性

C＃属性に似た概念（および同様の構文でも）。 このため、開発者に感謝します。 予想どおり、属性は注釈を付けるエンティティにメタ情報を追加し、

 #[cfg(target_os = "win32")] fn register_win_service() { /* ... */ }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

属性構文の別のバリアントが発明されました-同じ行ですが、最後にセミコロンがあり、現在のコンテキストに注釈を付けます。 つまり、そのような属性をカバーする最も近い中括弧に一致するものです。

 fn register_win_service() { #[cfg(target_os = "win32")]; /* ... */ }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

並列計算

おそらく、言語の最も興味深い部分の1つです。 さらに、チュートリアルは現在のところまったく説明されていません:)

Rustプログラムは、「タスクツリー」で構成されています。 各タスクには、入力関数、独自のスタック、他のタスクとの相互作用の手段（発信情報のチャネルと着信のポート）があり、動的ヒープ内のオブジェクトの一部を所有しています。

多くのRustタスクは、同じオペレーティングシステムプロセス内に存在できます。 Rustタスクは「軽量」です。各タスクはOSプロセスよりもメモリを消費せず、OSプロセス間の切り替えよりもタスク間の切り替えが高速です（ここでは、おそらくすべて同じ「フロー」を意味します）。



タスクは、引数のない少なくとも1つの関数で構成されます。 タスクは、spawn関数を使用して起動されます。 各タスクには、他のタスクに情報を転送するチャネルを含めることができます。 チャネルは、チャネルデータタイプによってパラメータ化された特別なchanタイプのテンプレートです。 たとえば、chanは符号なしバイトを送信するためのチャネルです。

チャネルに送信するには、send関数を使用します。最初の引数はチャネルで、2番目は送信する値です。 実際、この関数は値を内部チャネルバッファに配置します。

ポートはデータの受信に使用されます。 ポートは、ポートデータタイプによってパラメーター化された汎用ポートタイプです。ポート-符号なしバイトを受信するためのポート。

ポートから読み取るには、recv関数が使用されます。引数はポートであり、戻り値はポートからのデータです。 読み取りはタスクをブロックします。 ポートが空の場合、別のタスクがポートに接続されているチャネルにデータを送信するまで、タスクは待機状態になります。

チャネルをポートにリンクするのは非常に簡単です-chanキーワードを使用してポートでチャネルを初期化することにより：

let reqport = port();

let reqchan = chan(reqport);





複数のチャネルを1つのポートに接続できますが、その逆はできません。1つのチャネルを複数のポートに同時に接続することはできません。

タイプステート

「typestate」の概念のロシア語への一般的に受け入れられている翻訳が見つからなかったため、「type state」と呼びます。 この機能の本質は、静的型付けで採用されている通常の型制御に加えて、コンパイル段階で追加のコンテキストチェックが可能であることです。

何らかの形で、型の状態はすべてのプログラマーによく知られています-コンパイラーによると、「変数は初期化なしで使用されます」。 コンパイラーは、これまでレコードがなかった変数が読み取りに使用される場所を決定し、警告を生成します。 より一般的には、この考えは次のようになります。各オブジェクトには、取り得る状態のセットがあります。 このオブジェクトの各状態では、有効な操作と無効な操作が定義されています。 また、コンパイラは、ある場所または別の場所でオブジェクトに対する特定の操作が許可されているかどうかを確認できます。 これらのチェックは、コンパイル段階で実行することが重要です。



たとえば、「file」タイプのオブジェクトがある場合、「closed」および「open」の状態になります。 また、ファイルが閉じられている場合、ファイルからの読み取り操作は受け入れられません。 現代の言語では、通常、読み取り関数は例外をスローするか、エラーコードを返します。 型状態システムは、コンパイル段階でそのようなエラーを検出できます-コンパイラが、可能な読み取り操作の前に変数読み取り操作が発生すると判断するのと同様に、ファイルのオープン状態で有効なReadメソッドが呼び出されると判断できますオブジェクトをこの状態に転送する「Open」メソッドに。



Rustには「述語」という概念があります-副作用がなく、ブール型を返す特別な関数です。 このような関数は、特定の条件の静的チェックの目的でコンパイル段階で呼び出されるコンパイラーによって使用されます。



制約は、コンパイル段階で実行できる特別なチェックです。 これを行うには、checkキーワードを使用します。

 pure fn is_less_than(int a, int b) -< bool { ret a < b; } fn test() { let x: int = 10; let y: int = 20; check is_less_than(x,y); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この方法で、関数の入力パラメーターに述語を「ハング」させることができます。

 fn test(int x, int y) : is_less_than(x,y) { ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タイプステートに関する情報はほとんどないため、多くの点はまだ明確ではありませんが、コンセプトはとにかく興味深いものです。



以上です。 それにもかかわらず、私はいくつかの興味深い点を見逃した可能性がありますが、記事はすでに膨れ上がっていました。 必要に応じて、Rustコンパイラをコンパイルし、さまざまな例を試してみてください。 アセンブリ情報は、 公式言語のWebサイトで入手できます。