2 年 ago
雅, 悟
4 minutes

RustとRubyの違い

Mut

    Ruby: 変数は値変えられます
hoge = 1
hoge = 2
p hoge

# 結果: => 2
    Rust: 変数は値変更不可(immutable)
fn main() {
  let hoge = 1;
  hoge = 2;

  <!-- 
    ビルドエラー 
    error[E0384]: cannot assign twice to immutable variable `hoge` 
  -->


  println!("Hoge {:}", hoge);
}
    Rust: 変数の値変更したい場合、mutを付けないといけません
fn main() {
  let mut hoge = 1;
  hoge = 2;

  println!("Hoge {:}", hoge);
  <!-- 結果: Hoge 2 -->
}

型

    Ruby: 変数の型がありません、コンパイラーは値から型を付けます (PHPなどと同じ)
hoge = "as"
a.class
# => String

hoge = 12
hoge.class
# => Integer
    Rust: 変数の型は変更出来ません、(C, Java, Cotlin, Swiftなどと同じ)
fn main() {
  let mut hoge = 1; 
  <!-- Hoge変数は `&str` 型になります-->

  hoge = "hola";
  // ビルドエラー 
  // error[E0308]: mismatched types
  //  |
  //  |     hoge = "hola";
  //  |            ^^^^^^ expected integer, found `&str`

  println!("Hoge {:}", hoge);
}

変数のReference

    Rustはreferenceがあります。(Cと同じ)
fn main() {

  let a: u8 = 10;
  let b = &a;
  println!("Pointer a: {:p}", b);
  println!("Value   a: {}", a);
  println!("Value   b: {}", b);
}

  // Pointer a: 0x7ffd469b821f
  // Value   a: 10
  // Value   b: 10
}
    Ruby: 全部はobjectなので、変数はPointerです。Rustの書き方が存在しません
a = 12
b = &a

# コンパイラーエラー
# SyntaxError ((irb):23: syntax error, unexpected &)
    RubyのReference
class Hoge attr_accessor :name end
hoge = Hoge.new
fuga = hoge

hoge.name = "hoge"
p fuga.name
# 結果
# => "hoge"

fuga.name = "fuga"
p hoge.name
# 結果
# => "fuga"

質問1

fn main() {

  let mut a: u8 = 10;
  let b = &mut a;

  a = 11;
  println!("Value a: {:}", a);
}

→　エラーがありますか？

質問1の答え

    エラーはありません

質問2

fn main() {

  let mut a: u8 = 10;
  let b = &mut a;

  a = 11;
  println!("Value b: {:}", b);
}

→　結果はどうなりますか？

質問2の答え

    エラー発生します
 --> src/main.rs:7:3
  |
7 |   a = 11;
  |   ^
  |
  = note: `#[warn(unused_assignments)]` on by default
  = help: maybe it is overwritten before being read?

error[E0506]: cannot assign to `a` because it is borrowed
 --> src/main.rs:7:3
  |
5 |   let b = &mut a;
  |           ------ borrow of `a` occurs here
6 |   
7 |   a = 11;
  |   ^^^^^^ assignment to borrowed `a` occurs here
8 |   println!("Value b: {:}", b);
  |                            - borrow later used here

error: aborting due to previous error; 1 warning emitted

Borrowing と Ownership

    Rubyでオーナーとういう概念がない、複数変数はひとつのデータに参照するときに、どの変数でもデータ変更できます
class Hoge attr_accessor :name end
hoge = Hoge.new
fuga = hoge

hoge.name = "hoge"
p fuga.name
# 結果
# => "hoge"

fuga.name = "fuga"
p hoge.name
# 結果
# => "fuga"
    Rust: 一つの変数だけデータ変更できます。
struct Hoge {
    count: i32,
}
fn main() {
    let mut hoge = Hoge {count: 1};
    let fuga = &mut hoge;
    fuga.count = 2;
    println!("Hoge count: {:}", hoge.count);
    hoge.count = 3;
    println!("Hoge count: {:}", fuga.count);

    //     error[E0502]: cannot borrow `hoge.count` as immutable because it is also borrowed as mutable
    //   --> src/main.rs:8:33
    //    |
    // 6  |     let fuga = &mut hoge;
    //    |                --------- mutable borrow occurs here
    // 7  |     fuga.count = 2;
    // 8  |     println!("Hoge count: {:}", hoge.count);
    //    |                                 ^^^^^^^^^^ immutable borrow occurs here
    // 9  |     hoge.count = 3;
    // 10 |     println!("Hoge count: {:}", fuga.count);
    //    |                                 ---------- mutable borrow later used here

    // error[E0506]: cannot assign to `hoge.count` because it is borrowed
    //   --> src/main.rs:9:5
    //    |
    // 6  |     let fuga = &mut hoge;
    //    |                --------- borrow of `hoge.count` occurs here
    // ...
    // 9  |     hoge.count = 3;
    //    |     ^^^^^^^^^^^^^^ assignment to borrowed `hoge.count` occurs here
    // 10 |     println!("Hoge count: {:}", fuga.count);
    //    |                                 ---------- borrow later used here
}

Nil vs Option

    Ruby: どの変数でもnil付けられます
  x = 2;
  y = nil;

  print "x: #{x}, y: #{y}"
  # 結果
  # x: 2, y: => nil
    Rust: nilは存在しません　→　代わりにデータがある・ないの型があります　→　Option

fn main() {
    let x: Option<u32> = Some(2);
    let y: Option<u32> = None;

    println!("x: {:?}, y: {:?}", x, y)
}
    • Rust OptionのNone = Rubyのnil

 

    RUst OptionのSome = RUbyのnilじゃない
    Ruby: Nilに関連するoperatorがありません
a = nil
b = a + 1
# NoMethodError (undefined method `+' for nil:NilClass)
    Rust: Optionに関連するoperatorもありません、ただOptionのデータで使うとときに、Noneをチェックしないといけません　→　安全です
fn main() {
  let a: Option<u32> = Some(2);

  let value = match a {
    Some(v) => v,
    None => 0 
  };

  let b = value + 1;

  println!("b: {:}", b);
}

Result – エラーハンドリング

    エラーは外部APIまたは特別な処理の時に、エラー発生します。

例：　FbApiError, ValidationError..

    Ruby: 関数開発の時にエラー気にしなくも開発出来ます

def call_api(endpoint, method)
   fb_client.call(endpoint, method) # エラーがある処理

   'API Done'
end
    Ruby: エラーハンドリングの時に開発者に決められます。

def call_api(endpoint, method)
  begin
    fb_client.call(endpoint, method)
  rescue => exception
    'API ERROR'
  end

  'API Done'
end
    Ruby: エラーハンドリングしないと関数が呼ばれるところにエラー投げます。
def call_api(endpoint, method)
   fb_client.call(endpoint, method) # エラーがある処理

   'API Done'
end

call_api("me", "GET") # fb_client.call でエラー発生したら、ここに止まります。
    Rust: 関数開発の時にエラーがあれば、Resultとうい型になります。
    pub async fn call_api(&self, endpoint: &str, method: &str) -> String{
        self.call(endpoint, method) // エラーがある処理

        "API DONE".to_owned()
    }
    Rust: Resultをみるとエラーがあるかどうか分かります。
    pub async fn call_api(&self, endpoint: &str, method: &str) -> String{
        return match self.call(endpoint, method) {
             Ok(value) => "API DONE".to_owned(),
             Err(error) => "API ERROR".to_owned()
        }
    }
    Rust: エラーハンドリングしないときに、エラー発生したら何も起こらない
    pub async fn call_api(&self, endpoint: &str, method: &str) -> String{
        await self.call(endpoint, method) // エラーがある処理

        "API DONE".to_owned()
    }

    pub async fn run(&self){
        await self.call_api("me", "GET") // .call でエラー発生しても、何も起こらない
    }

まとめ

    • Mut

 

    • 型

 

    • Reference

 

    • Nil/Option

 

    Result
bannerAds