Vlákno názorů k článku Rust: programovací jazyk do aut, vlaků a letadel od Filipeus - Za mě je Rust super jazyk pro tvorbu...

Za mě je Rust super jazyk pro tvorbu GraphQL api nebo RPC. Hlavně z hlediska výkonu. Oproti skriptovacím jazykům (PHP, NodeJS/Javascript) je úplně jinde.

Oproti Go je taky výkonnější a to hlavně, protože má lepší správu paměti (nemá garbage collector). Co se týče syntaxe jazyka má blíž k skriptovacím jazykům. Go mi přijde, že má blíže k C++.

Pro GraphQL api používám kombinaci knihovny Actix-web (http server) a Juniper (GraphQL protokol). Líbí se mi, že http server běží ve více vláknech + v Rustu asynchronní programování je stejné jako v Javascriptu (jenom Promise se tam jmenuje Feature).

Mimo to v Rustu existuje frontendový framework Yew, který funguje stejně jako React. Jsou v něm funkcionální komponety, states, kotexty, pomocí maker je tam něco JSX, ... . Celý projekt se kompiluje do WebAssembly.

31. 10. 2023, 20:47 editováno autorem komentáře

Napsat, že Go má blízko k C++ :-D

Ne, fakt nemá...

Spíš jsem tím chtěl říct, že Rust má z mého pohledu přehledněší syntaxi a jednodušší zápis než Go. Viz. třeba asynchronní funkce.

Příklad?

V Rustu mi příjde, že je přehledněší typování (používá se dvojtečka) a v asynchroním programování používá await.

use tokio::time::{Duration, sleep};
use futures::future::join_all;

#[tokio::main]
async fn main() {
    let strings: Vec<&str> = vec!["apple", "banana", "cherry"];
    let tasks = strings.iter().map(|&s| async_task1(s));

    let results = join_all(tasks).await;

    // Zde můžete pracovat s výsledky úkolů
    for result in results {
        match result {
            Ok(res) => println!("Task result: {}", res),
            Err(err) => eprintln!("Task error: {}", err),
        }
    }
}

async fn async_task1(s: &str) -> Result<String, Box<dyn std::error::Error>> {
    // Simulace asynchronního úkolu
    sleep(Duration::from_secs(2)).await;

    let result = format!("Processed: {}", s);

    Ok(result)
}

Zde je kód v Go:

package main

import (
    "fmt"
    "time"
)

func asyncTask1(input string, ch chan string) {
    // Simulace asynchronního úkolu
    time.Sleep(2 * time.Second)
    result := "Processed: " + input
    ch <- result
}

func main() {
    strings := []string{"apple", "banana", "cherry"}
    ch := make(chan string)

    for _, s := range strings {
        go asyncTask1(s, ch)
    }

    results := make([]string, len(strings))

    for i := 0; i < len(strings); i++ {
        result := <-ch
        results[i] = result
    }

    // Zde můžete pracovat s výsledky úkolů
    for _, result := range results {
        fmt.Println(result)
    }
}

Zde je ještě pro porovnání Typescript, který má viditelně podobnější sytaxi k Rustu. Proto mi přijde jednoduší přechod z PHP nebo NodeJS do Rust než do Go.

async function asyncTask1(input: string): Promise<string> {
  // Simulace asynchronního úkolu
  await new Promise((resolve) => setTimeout(resolve, 2000)); // 2 sekundy
  return `Processed: ${input}`;
}

const strings: string[] = ["apple", "banana", "cherry"];

async function main() {
  const promises: Promise<string>[] = strings.map(async (s) => asyncTask1(s));

  const results: string[] = await Promise.all(promises);

  // Zde můžete pracovat s výsledky úkolů
  results.forEach((result) => console.log(result));
}

main();

mi se zda, ze go je pro ceckare a rust pro c++kare.

Souhlas, spletl jsem se a měl jsem na mysli C.

> mi se zda, ze go je pro ceckare a rust pro c++kare.

To zní trochu paradoxně, když Rust je zjevně víc low-level než Go. (Ale neříkám, že podle jiných kritérií to tak nemůže být. Zejména moje znalost Go je dost omezená.)

Smart pointers, RAII, zero cost (zero overhead) abstrakce, přetěžování operátorů, generické typy - řekl bych, že Rust toho s C++ sdílí docela dost.

1. 11. 2023, 13:35 editováno autorem komentáře