👩🏾‍💼 🧖🏽 🤸 जावा डेवलपर्स के लिए जंग 🥥 ☕️ 📽️

मैं इवान कैमरन द्वारा एक लेख का अनुवाद प्रस्तुत करता हूं , जो जावा डेवलपर्स को दो भाषाओं के बीच अंतर और समानता को बेहतर ढंग से समझने में मदद कर सकता है - मूल लेखक की साइट पर है । अपने आप को एक अनुभवी रस्ट डेवलपर नहीं मानते हुए, मैं संभावित चर्चाओं में यथोचित रूप से भाग लेने में सक्षम होने की संभावना नहीं हूं।

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

जावा एक ऐसी भाषा थी जिसका मैंने विश्वविद्यालय में अध्ययन किया था, इसलिए इसके साथ मेरा अनुभव कुछ हद तक कठिन है और मैंने भाषा को बनाए रखने के लिए कोई वास्तविक प्रयास नहीं किया है। जब मैंने अंतिम बार जावा लिखा था, यदि आप एक फ़ंक्शन को एक तर्क के रूप में पारित करना चाहते थे, तो आपको एक नया इंटरफ़ेस घोषित करना होगा या फ़ंक्शन को लपेटना होगा Callable<T>। तब से, जावा ने एक लंबा सफर तय किया है। ये ऐसे कार्य हैं जिन्हें कार्यात्मक प्रोग्रामिंग से स्पष्ट प्रभाव पड़ता है। मैं लंबोदर, Optionalप्रकार, आदि के बारे में बात कर रहा हूं । यह लेख बात नहीं करेगा कि रस्ट में कैसे लिखें या आपको अपने सभी जावा कोड को फेंकने की आवश्यकता है। जावा वास्तविक उपयोग के मामलों के साथ एक महान भाषा है। मैं एक शुरुआती रस्ट प्रोग्रामर के लिए जावा और रस्ट की कुछ तुलना करना चाहता हूं।

भाषा की प्रेरणा

पहले प्रत्येक भाषा के लक्ष्यों के बारे में। कई समस्याओं को हल करने के लिए जावा बनाया गया था। यह "सरल, ऑब्जेक्ट-ओरिएंटेड और मॉड्यूलर" होना था , इसे एक वर्चुअल मशीन में काम करना था, विभिन्न आर्किटेक्चर के लिए पोर्टेबल होना था, और इसके लिए उच्च प्रदर्शन करना था। रस्ट के लक्ष्य "अविश्वसनीय रूप से तेज़ और मेमोरी कुशल" होने के लिए हैं , एक "रिच टाइप सिस्टम, मेमोरी सिक्योरिटी, थ्रेड-सेफ" हैं, अच्छी त्रुटि संदेश उत्पन्न करते हैं और एक अंतर्निहित पैकेज मैनेजर हैं।

. Rust , , . , Rust , . , , , , ( ) , (embedded) . , Rust. Rust , , (dangling) .

, Rust ( wasm frontends yew ). , , , , ( ) . .

, , Java Rust :

( GC)
()

; , , . , .

Rust . Rust enum struct. enum — ( , ). enum Java, , Java enum, . enum , , . , , Rust null nil. Rust, .

enum Option<T> {
    None,
    Some(T),
}

Option, T. T , T. Option 2 , None (" ") , Some T. :

let a = Some("foo".to_string()); //    Option<String>

let b: Option<usize> = Some(1); //    Option<usize>,

. , . , . , .

Rust enum match. , .

fn plus(a: Option<usize>) -> Option<usize> {
    match a {
        Some(v) => Some(v + 1),
        None => None
   }
}

, . match. cheats.rs match. if/else.

Option, - ( Some ) . , Option , .

fn plus(a: Option<usize>) -> Option<usize> {
    a.map(|v| v + 1)
}

|| {} — . Rust - , , " " .

struct — . , , , .

struct A {
   field: usize
}

"" .

let a: (usize, usize) = (1, 1); //

struct Foo<T> {
    field: T
}

enum struct . , impl . , Rust. struct impl , :

struct Thangs {
   list: Vec<Thang>
}

struct Thang;

impl Thangs {
   // **  `new`    ,   ' '
   fn new() -> Self {
       Self {
           list: vec![]
       }
   }

   fn add_thang(&mut self, thang: Thang) {
       self.list.push(thang);
   }
}

fn main() {
  // ** &mut self   'add_thangs'   mut   
   let mut thangs = Thangs::new();
   thangs.add_thang(Thang);
}

Java, value.method() " ". , &mut self :

let mut thangs = Thangs::new();
Thangs::add_thang(&mut thangs, Thang);

, Rust . enum struct . Java - struct impl , "", ( , ). " Rust ", Java , . Java 14 "Records" () . , Java "", ( , Rust , sum product ). Java, - , , !

Rust . , . . :

struct Thing { field: usize }

fn main() {
    let a = Thing { field: 1 };
    // .. do stuff with a
}

- . , , Sized. , . , ( main) .

Java, new, , .

Box ( stdlib , Rc, Arc ..). , , ? , , , , ( ). , , , , "" Box , .

fn main () {
    let a = Box::new(Thing { field: 1 });
}

, . , . , , a a. usize , .

Box . - Java,

trait Foo {}

struct Thing;

impl Foo for Thing {}

struct OtherThing;

impl Foo for OtherThing {}

fn main () {
    let a: Vec<Box<dyn Foo>> = vec![Box::new(OtherThing), Box::new(Thing)]; //   
    //  ''     ,    
    //            Foo
    }

trait, . , . , . Rust , , , , .

, , . Rust — .

enum List<T> {
    Nil,
    Cons((T, List<T>))
}

. List<T> Nil , Cons, . , , ?
?

    error[E0072]: recursive type `List` has infinite size
     --> src/lib.rs:7:1
      |
    7 | enum List<T> {
      | ^^^^^^^^^^^^ recursive type has infinite size
    8 |     Nil,
    9 |     Cons((T, List<T>))
      |          ------------ recursive without indirection
      |
      = help: insert indirection (e.g., a `Box`, `Rc`, or `&`) at some point to make `List` representable

. help . , , . , , , N-? , , ? , . .

, .

enum List<T> {
    Nil,
    Cons((T, Box<List<T>>))
}

. , . .

Java Rust, ( ) :

enum Shape {
    Circle { radius: f32 },
    Rectangle { width: f32, height: f32 },
}

area () , , , :

impl Shape {
    pub fn area(self) -> f32 {
        match self {
            Shape::Circle { radius } => std::f32::consts::PI * radius.powi(2),
            Shape::Rectangle { width, height } => width * height,
        }
    }
 }

Java . Rust pub ( ), ( ). , Rust reference.

. Java Shape Circle Rectangle, area. Rust Java, :

Shape:
- Java: Shape
- Rust: Shape , ( match , )
Shape:
- Java: "" Shape, ,
- Rust: impl

' ' (expression problem). . enum Rust / Java. , Rust match enum. : « , ?»

, .

trait Area {
    fn area(self) -> f32; //          ( i32)
}

struct Rectangle {
    width: f32,
    height: f32
}

struct Circle {
    radius: f32
}

impl Area for Rectangle {
    fn area(self) -> f32 {
        self.width * self.height
    }
}

impl Area for Circle {
    fn area(self) -> f32 {
        std::f32::consts::PI * self.radius.powi(2)
    }
}

, Circle Rectangle, perimeter, :

trait Perimeter {
    fn perimeter(self) -> f32;
}

impl Perimeter for Rectangle {
    fn perimeter(self) -> f32 {
        2. * (self.width + self.height)
    }
}
//  ..

. , , "" " ".

fn do_something<T: Perimeter + Area>(shape: T) { //   ,    Perimeter  Area
        unimplemented!() // :   
        //        
    }

Rust . , , Java. , . Java , Rust . , . , , . Future , Iterator IntoIterator for..in, Index [], Add, Sub, Mul . , Add

Add std.

pub trait Add<Rhs = Self> { // 1
    type Output; // 2
    fn add(self, rhs: Rhs) -> Self::Output; // 3
}

Std Add Rhs, Self, .. (1). « » Output (2) add, self ( self) rhs Rhs ( ) , Output (3).

use std::ops::Add;

#[derive(Debug)]
struct Content<T> { // 1
    val: T,
}

impl<T> Add for Content<T> // 2
   where
    T: Add, // 3
{
    type Output = Content<<T as Add>::Output>; // 4
    fn add(self, rhs: Content<T>) -> Self::Output {
        Content {
            val: self.val + rhs.val,
        }
    }
}

fn main() {
    let a = Content { val: 2 };
    let b = Content { val: 5 };
    println!("{:?}", a + b); // Content { val: 7 }
}

Content, T (1). Add , Content Add (2), , Content Add (3). , Output Content Output T, Add (4). , , , . , , . , " " , Rust. , Rust , ( ), .

, Sized , fn foo<T>(t: T) -> T, T: Sized. T: ?Sized, T . .

Java . OO Rust, Java. Java — (subtype polymorphism), Rust — (ad-hoc) . , , , ( <T: Trait> ).

, "" . , enum struct, impl. impl , . , , -. .

Rust . str, String, OsStr, OsString, CString CStr ( - ?). , str String, — . , , ?

&str , &str &String , String Deref<Target=str> ( Target= , Target " "). .

fn foo<S: AsRef<str>>(s: S) {
    unimplemented!()
}

AsRef — stdlib. :

trait AsRef<T>
  where
    T: ?Sized,
{
    fn as_ref(&self) -> &T;
}

, T, , &T. foo String,

let a = String::from("stuff");
foo(a);

? , ( ). Rust stdlib.

, . , , . , . Java ( , Java ). Java , . « ». Rust , .

, , . , - . , , . Rust , ! , Rust .

: Java Rust

Java , . , . - Java , .. . , , Java , ( Java <T> <T extends Class> ), Java , (type erasure). , Object -. Java, , — . - vtable, .

Rust . foo foo , foo . , foo 4 AsRef<str>, 4 . «». , Rust " ". ( Box), Objectअगर हम नहीं चाहते हैं तो एक वर्चुअल टेबल ट्रांसफर करें। यह ध्यान दिया जाना चाहिए कि इस पद्धति का नुकसान अंतिम कोड आकार और संकलन समय है। हमारे कार्यों के कितने अलग-अलग प्रकार हैं और हमें कितने कार्यान्वयन की आवश्यकता है, इस पर निर्भर करते हुए, अधिक कोड LLVM के माध्यम से जाना चाहिए, संकलन समय बढ़ाना और वास्तव में उत्पन्न कोड की मात्रा में वृद्धि करना।

संपर्क इवान कैमरन: मेल , जीथब , ट्विटर , लिंक्डइन

रस्ट अनुवाद की धीमी चर्चा रस्ट अनुवाद के लिए एक टेलीग्राम चैट में होती है ।

जावा डेवलपर्स के लिए जंग

भाषा की प्रेरणा

: Java Rust

More articles: