Typescriptben ezt tudom megtenni:
function foo(param: { a: string, b: number }) { }
Egy objektumot fogadó függvény deklarálásához anélkül, hogy a paramétertípust kifejezetten elnevezett típusként deklarálnák, például:
interface Parameter {
a: string;
b: number;
}
function foo(param: Parameter) {}
Meg tudom ezt valahogy tenni Rustban, vagy kifejezetten deklarálnom kell a paraméter típusát nevesített típusként?
A Rust rendelkezik minta dekonstrukcióval a függvény paramétereihez sorokon, tömbökön és struktúrákon, például:
fn f((a, b): (u32, i32), [x, y, z]: [String; 3]) { }
struct A { a: u32, b: String }
fn g(A { a, b }: A) { }
De nincs ilyen szintaxisa a névtelen típusokhoz / objektumokhoz, mivel az objektumok egyszerűen nem léteznek a rozsdában. Képzeld el, hogy a rozsdának volt egy szintaxisa ehhez:
fn f(param: {a: String, b: String}) {} // Invalid code!
Hogy hívná valaki ezt a funkciót? Nincs mód ilyen típusú példány létrehozására. A javascriptben (/typescript) ez lehetséges, a dinamikus gépelés miatt, de a rozsdában ismerni kell egy típust, hogy meg tudd építeni.
Ha érdekli a kulcsszóargumentumok hamisítása a függvényekben, ez segíthet: Hogyan lehet a legjobban *hamisítani* kulcsszóstílus-függvény argumentumokat a Rust-ban?
Ha nevet szeretne adni a soroknak, valamint a paramétereiknek, akkor az instabil bindings_after_at-szolgáltatás engedélyezi ezt a szintaxist:
#![feature(bindings_after_at)]
fn f(my_tuple @ (a, b): (u32, u32)) {
println!("this: {:?}", my_tuple);
println!("is the same as: {:?}", (a, b));
}
// or this
fn g(arr @ [.., tail] : [u32; 5]) {
println!("this: {}", arr[4]);
println!("is the same as: {}", tail);
}
Használhat tuplet:
fn foo(param: (String, usize)) {
let a: String = param.0;
let b: usize = param.1;
}
Ahelyett, hogy a mezőket, például a struktúrákat elneveznénk, a sorértékek indexelésre kerülnek. A sor strukturálása megkönnyíti az értékek nyomon követését:
fn foo((a, b): (String, usize)) {
// you can now access `a` and `b` here
}
A Rustban nem tehetsz ilyeneket, mert névleges típusú rendszere van, és a kódod a szerkezeti típusú rendszerek példája. A wikipédián olvashatsz róluk: https://en.wikipedia.org/wiki/Nominal_type_system https://en.wikipedia.org/wiki/Structural_type_system
A szerkezeti típusrendszerben a típus csak a mezőiből áll, és a neve és a definíciója nem számít. Ezzel szemben a nominális típusú rendszer 2 különböző deklarációjú, de azonos mezőkészlettel rendelkező típust kezel eltérőként (vagyis a típus neve fontosabb, mint a tartalom).
A rozsda azért választott névleges, mert feltűnőbb, és lehetővé teszi a program bizonyos tulajdonságainak típusszintű érvényesítését. Tekintsük ezt a példát:
struct Employee(String);
struct Customer(String);
fn handle_order(employee: Employee, customer: Customer){}
Ha a programozó hibázott, és handle_order(customer, employee)-ként hívja, akkor ez egy olyan hiba, amelyet a strukturális gépeléssel nem lehet észrevenni, de a névleges gépelésnél fordítási hibát vált ki.
Előfordulhat olyan helyzet is, amikor a programozónak módosítania kell a típusdefiníciót, például egy mezőt kell hozzáadnia a Employee-hoz. Ebben az esetben biztos lehet benne, hogy az átalakítás megtörtént, amikor az Employee minden felhasználása megoldódott. Strukturális tipizálást használó programban nem lehet biztosra menni, mert előfordulhat olyan kód, amely a Vevőt küldi el helyette, és így a strukturális típusos programok átalakítása kicsit nehezebb.
A névleges gépelés másik híres példája a Rust nyelvben az élettartamok. Az azonos típusú és eltérő élettartamú változóknak valójában különböző névleges típusai vannak. És minden Rusts biztonság ezen alapul.
A Typescript strukturális gépelést használ, mert könnyebben leképezhető JavaScriptbe.
