Adapter օրինակը Rust-ում. Orphan Rule-ի շրջանցումը newtype-երի և extension trait-երի միջոցով
Այս հոդվածը դիտարկում է Adapter օրինակը Rust-ում՝ որպես Orphan Rule-ի հետ գործ ունենալու գործնական միջոց. սա լեզվի սահմանափակում է, որն արգելում է արտաքին trait-երը իրականացնել արտաքին տիպերի համար։ Այն սկսվում է հստակ բացատրությամբ, թե ինչու է գոյություն ունի Orphan Rule-ը և ինչ կոմպիլյացիոն խնդիրների է հանգեցնում, ապա քայլ առ քայլ ցույց է տալիս, թե ինչպես կառուցել newtype-ի վրա հիմնված ադապտեր, ինչպես այն դարձնել հղում պահող ադապտեր բացահայտ lifetime-ներով և ինչպես ամեն ինչ փաթաթել extension trait-ի մեջ՝ մաքուր, հարմար API ստանալու համար։ Իրական օրինակը կապում է axum և eyre crate-երը՝ ցույց տալով, թե ինչպես մի քանի մասնագիտացված ադապտերներ կարող են սխալները համապատասխանեցնել HTTP կարգավիճակի որոշակի կոդերի։ Հոդվածը քննարկում է նաև դիզայնի հարցեր, ինչպիսիք են Deref և AsRef իրականացումները, հանրային ընդդեմ մասնավոր ներքին դաշտերի, և իրավիճակներ, երբ երրորդ կողմի տարբերակները, ինչպես serde-ի remote շարահյուսությունը, կարող են ավելի հարմար լինել, քան ձեռքով գրված ադապտերը։
Սկզբում հիշենք Newtype օրինակը Rust ծրագրավորման լեզվում։ Այդ օրինակում մեկ դաշտով tuple struct-ը ծառայում է կա՛մ ներքին տիպի իմաստաբանությունը փոխելու, կա՛մ իրականացման տիպը վերջնական օգտատերից թաքցնելու համար, և հաճախ մենք երկուսին էլ ենք ձգտում։
Այս գրառման մեջ մենք նորից կքննենք մեկ դաշտով tuple struct-ը, բայց այս անգամ այն կօգտագործենք adapter օրինակն իրականացնելու համար։ Սկսենք նկարագրելով այն խնդիրը, որը այն նախատեսված է լուծելու։
Orphan Rule
Իմ փորձով՝ Rust-ի տիպերի համակարգը իսկապես հասկանալու համար ամենադժվար բաներից մեկն է, պարզապես այն պատճառով, որ այն այնքան շատ է տարբերվում մեզ սովոր օբյեկտ-կողմնորոշված լեզուներից։
Նրա անսովոր կողմերից մեկն այն է, թե ինչպես են Trait-երը կապվում օգտատիրոջ սահմանած տիպերի հետ։ Trait-երը սովորաբար ներկայացվում են որպես ինտերֆեյսների իրականացում։ Քանի որ երկուսն էլ նման դեր են խաղում՝ աբստրակցիա վարքի մակարդակում, ես անձամբ խուսափում եմ trait-երը շատ հեշտությամբ ինտերֆեյս անվանելուց, քանի որ նրանց միջև կա կարևոր տարբերություն։ Մենք սովորաբար ինտերֆեյսները դիտարկում ենք որպես տիպի հետ կապված այն կետում, որտեղ տիպը հայտարարվում է։ Այսպես, երբ սահմանում ենք Orc տիպը, անմիջապես թվարկում ենք բոլոր ինտերֆեյսները, որոնք այն իրականացնում է՝ Creature, Foe, Mesh։ Trait-երն այդպես չեն աշխատում։ Rust-ում trait-երն ու տիպերը լիովին օրթոգոնալ են և սահմանվում են միմյանցից անկախ։ Հանրային տիպերի համար երբեք չեք կարող պնդել, թե գիտեք տիպի համար իրականացված բոլոր trait-երը՝ կախյալ crate-երը միշտ կարող են ավելացնել այդ բազմությանը։
Սա, սակայն, խնդիր է ստեղծում։ Ենթադրենք՝ ունենք երկու crate՝ crate1 և crate2, որոնցից յուրաքանչյուրը բաղկացած է մեկ lib.rs ֆայլից՝
// crate1/lib.rs
trait Applicator {
fn apply(&self, a: u32) -> u32;
}
// crate2/lib.rs
struct Multiplicator {
pub scale: u32,
}
crate2-ի հեղինակը ոչինչ չգիտի crate1's existence-ի մասին, և հակառակը։ Սակայն կա crate3, որի հեղինակն ուզում է օգտագործել երկու crate-երը և նրան պետք է, որ Applicator-ը իրականացված լինի Multiplicator տիպի համար՝
use crate1::Applicator;
use crate2::Multiplicator;
impl Applicator for Multiplicator {
fn apply(&self, a: u32) -> u32 {
self.scale * a
}
}
Սա խելամիտ է թվում, և դա մի բան է, որ իսկապես կուզենայինք կարողանալ անել։ Վատ լուրը. այս կոդը չի կոմպիլյացվի։ Դիտարկենք, թե ինչու է դա խնդիր։
Սա տեսնելու համար ավելացնենք crate4, որը մի փոքր այլ պատկերացում ունի, թե ինչպես պետք է Applicator-ը իրականացվի Multiplicator-ի համար՝
use crate1::Applicator;
use crate2::Multiplicator;
impl Applicator for Multiplicator {
fn apply(&self, a: u32) -> u32 {
a.pow(self.scale)
}
}
Մինչ այստեղ ամեն ինչ լավ է, չէ՞։ crate3-ը հենվում է իր սեփական trait իրականացման վրա, crate4-ը՝ իրենը, և ամեն ինչ կարգին է։ Բայց ամեն ինչ բարդանում է, երբ ավելացնում ենք crate5, որը կախված է մինչ այժմ նշված բոլոր crate-երից՝
use crate1::Applicator;
fn main() {
let m = crate2::Multiplicator { scale: 3 };
println!("{}", m.apply(3));
}
Ահա հարցը. ի՞նչ է տպում crate5-ը՝ 9 թե՞ 27։ Ոչ մի կերպ հնարավոր չէ ասել, թե որ իրականացումն է ճիշտը։
Հնարավոր պատասխաններից մեկը. պարզապես հրաժարվել կոմպիլյացիայից, երբ այս իրավիճակն առաջանում է։ crate5-ը կարող էր պարզապես կոմպիլյացիայի սխալ առաջացնել Multiplicator-ի համար Applicator-ի հակասող իրականացումների պատճառով։ Սակայն դա կարճատես կլիներ։ Գուցե crate5-ը գրելու պահին crate4-ին դեռ Applicator իրականացում պետք չէր, և ծրագիրը եղել է հենվել crate3-ի իրականացման վրա, որը միշտ եղել է։ Այդ իրավիճակում կոդը լավ կկոմպիլյացվեր, մինչև crate4-ը ներմուծեր իր նոր trait իրականացումը։ Սա այն չէ, ինչ մենք ուզում ենք. դա կախվածությունների կառավարումը չափազանց դժվար կդարձներ։
Դրա փոխարեն Rust-ի ստեղծողները կանգ առան այն բանի վրա, ինչը հայտնի է որպես Orphan Rule։ Նրա ամբողջական ձևակերպումը բավականին բարդ է, քանի որ ընդգրկում է generic-ներով որոշ դեպքեր, բայց պարզեցված տարբերակը, որը ես սիրում եմ օգտագործել, հետևյալն է՝
Տիպի համար trait իրականացնելու համար impl բլոկ պարունակող crate-ը պետք է տիրապետի trait-ին կամ տիպին։
Բարդ մասը վերաբերում է generic տիպերին. պարզվում է, որ այդ դեպքերում և՛ generic տիպը, և՛ trait-ը կարող են գալ արտաքին crate-երից, պայմանով որ impl բլոկ ունեցող crate-ը տիրապետում է generic-ը մասնագիտացնելու համար օգտագործվող տիպին։ Ամբողջական կանոնը նկարագրված է Rust-ի reference-ում։
Խնդիրը
Վերադառնանք վերը բերված օրինակի crate3-ին։ Ահա նրա կոդը կրկին՝
use crate1::Applicator;
use crate2::Multiplicator;
impl Applicator for Multiplicator {
fn apply(&self, a: u32) -> u32 {
self.scale * a
}
}
Ահա թե ինչ ենք ստանում, երբ փորձում ենք այն կոմպիլյացնել՝
error[E0117]: only traits defined in the current crate can be implemented for types defined outside of the crate
--> src/lib.rs:4:1
|
4 | impl Applicator for Multiplicator {
| ^^^^^^^^^^^^^^^^^^^^-------------
| |
| `Multiplicator` is not defined in the current crate
|
= note: impl doesn't have any local type before any uncovered type parameters
= note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
= note: define and implement a trait or new type instead
Բայց հենց սա է այն դեպքը, որն ամենից հաճախ պետք է գալիս։ Ես վերջերս հանդիպեցի այս խնդրին՝ վեբ սերվերի համար axum crate օգտագործելիս։ axum-ն ունի իր axum::response::IntoResponse trait-ը, որը նախատեսված է իրականացվելու այն տիպերի համար, որոնք կարելի է վերածել HTTP պատասխանի։ Այս trait-ի հարմար հատկությունն այն է, որ երբ axum::response::IntoResponse-ը իրականացված է և՛ T-ի, և՛ E-ի համար, այն իրականացված է նաև Result<T, E>-ի համար. այսպիսով մեզ պետք է միայն trait-ը իրականացնել մեր սահմանած սխալների տիպերի համար։
Քանի որ ես կառուցում եմ երկուական հավելված, այլ ոչ թե գրադարան, սխալների մշակման համար նախընտրում եմ eyre (կամ anyhow) crate-ը։ Ահա հանգույցը. axum-ը տեղյակ չէ այդ crate-երից և ոչ մեկի մասին։ Եվ ոչ մի crate չի իրականացնում axum-ի trait-երը։ Այսպես, եթե ուզում եմ, որ իմ eyre սխալները պարզապես 500 HTTP պատասխաններ տան, ես փակուղում եմ. չեմ կարող պարզապես trait իրականացնել։ Ուղիղ լուծումը Adapter օրինակն է։
Adapter օրինակը
Adapter օրինակը պարզապես newtype է, ճիշտ այնպես, ինչպես առաջարկեց կոմպիլյատորը, որն իրականացնում է այն trait-երը, որոնք մեր արտաքին տիպը չունի։ Օգտագործենք այն crate3-ը շտկելու համար՝
struct ApplicatorAdapter(crate2::Multiplicator);
impl crate1::Applicator for ApplicatorAdapter {
fn apply(&self, a: u32) -> u32 {
self.0.scale * a
}
}
impl ApplicatorAdapter {
fn new(src: crate2::Multiplicator) -> Self {
Self(src)
}
}
Հիմա Applicator trait-ն օգտագործելու համար պարզապես նախ կառուցում ենք ադապտերը՝
fn mul(a: u32, b: u32) -> u32 {
let m = Multiplicator { scale: a };
let adapter = ApplicatorAdapter::new(m);
adapter.apply(b)
}
Հղումը որպես հիմքում ընկած տիպ
Վերը նշված լուծումն արդեն աշխատում է։ Սակայն այն ունի մեծ թերություն. ադապտերը կառուցելը պահանջում է Multiplicator-ի լիարժեք սեփականություն։ Արդյունքում ադապտերն անօգուտ է, եթե ուզում ենք հետո պահել բնօրինակ օբյեկտը, կամ եթե մեզ մոտ միայն հղում կա, որը, հաշվի առնելով Applicator-ի սահմանումը, պետք է բավական լինի։
Սա լուծելու համար հաճախ ադապտերին ստիպում ենք ներսում պահել հղում՝ սեփական արժեքի փոխարեն։ Այս մոտեցմամբ crate3-ը կարող է այսպես տեսք ունենալ՝
struct ApplicatorAdapter<'a>(&'a crate2::Multiplicator);
impl crate1::Applicator for ApplicatorAdapter<'_> {
fn apply(&self, a: u32) -> u32 {
self.0.scale * a
}
}
impl<'a> ApplicatorAdapter<'a> {
fn new(src: &'a crate2::Multiplicator) -> Self {
Self(src)
}
}
Հղումը որպես ներքին տիպ օգտագործելը մեզ ստիպեց ավելացնել lifetime generic, քանի որ յուրաքանչյուր հղում պետք է կապված լինի ինչ-որ lifetime-ի հետ։ Այստեղ այն ապահովում է, որ ApplicatorAdapter struct-ը երբեք չի կարող ավելի երկար ապրել, քան Multiplicator-ը, որից կառուցվել է։ Դա տրամաբանական է. wrapper-ը հղում է պահում, ուստի եթե այն ավելի երկար ապրեր, քան ներքին Multiplicator-ը, կունենայինք չափազանց վտանգավոր կախված հղում։
Հիշեք, որ եթե Applicator trait-ի մեթոդը պահանջեր &mut self, մենք պարզապես կօգտագործեինք փոփոխվող հղում ներսում։ Սակայն դա որոշ չափով խնդրահարույց կլիներ. դա կնշանակեր միշտ փոփոխվող հղման կարիք ունենալ օբյեկտի նկատմամբ, նույնիսկ Applicator-ի &self մեթոդները կանչելու համար։ Այդ իրավիճակներում սովորական մոտեցումը սեփականատեր ադապտեր օգտագործելն է և այն ներքին օբյեկտի վերածելու API առաջարկելը, օրինակ՝ ադապտերի տիպի վրա fn into_inner(self) -> Multiplicator մեթոդը։
Ստեղծման համար extension trait
Adapter օրինակը մեզ օգնեց շրջանցել orphan rule-ը, բայց բերեց նոր խնդիր. API-ն դարձել է նյարդայնացնող։ Մեկ կանչի համար ստիպված ենք կառուցել մի ամբողջ նոր տիպ, անունը երկար է, և շատ նիշեր պետք է գրել ու կարդալ։ Կարող էինք կրճատել ադապտերի տիպի անունը, բայց նույնիսկ այդ դեպքում ստացված API-ն ինձ դուր չի գալիս։
Սովորական միջոցը Rust-ում շատ տարածված մեկ այլ օրինակ է՝ extension trait-ը։ Գաղափարն այն է, որ սահմանվի նոր crate-մասնավոր trait և իրականացվի ադապտացվող տիպի համար՝ դրանով նրան նոր ֆունկցիոնալություն տալով։ Orphan rule-ը մեր ճանապարհին չի կանգնի. trait-ի սահմանումը մերն է։ Ահա թե ինչպես կարող է դա տեսք ունենալ՝
trait AdapterBuilder {
fn applicator(&self) -> impl crate1::Applicator;
}
impl AdapterBuilder for Multiplicator {
fn applicator(&self) -> impl crate1::Applicator {
ApplicatorAdapter(self)
}
}
fn mul(a: u32, b: u32) -> u32 {
let m = Multiplicator { scale: a };
m.applicator().apply(b)
}
Applicator-ը կարելի է օգտագործել նաև այն ժամանակ, երբ մենք միայն Multiplicator-ի հղման հասանելիություն ունենք՝
fn mul1(m: Multiplicator, b: u32) -> u32 {
m.applicator().apply(b)
}
Deref և AsRef ադապտերի տիպի վրա
Հաջորդը կուզենայի անդրադառնալ մի փոքր վիճահարույց թեմայի. արդյո՞ք ադապտերի տիպերը պետք է իրականացնեն Deref, և գուցե DerefMut։
Ակնհայտ մեկնակետը Deref-ի փաստաթղթավորումն է՝
Զգուշացում. Deref coercion-ը լեզվի հզոր հնարավորություն է՝ լայն հետևանքներով ցանկացած տիպի համար, որն իրականացնում է Deref։ Կոմպիլյատորը լուռ մտցնում է Deref::deref-ի կանչեր։ Ահա թե ինչու Deref-ի իրականացումը զգուշություն է պահանջում և պետք է արվի միայն այն դեպքում, երբ deref coercion-ը ցանկալի է։ Ստորև բերված է ուղեցույց այն մասին, թե երբ է այն սովորաբար ցանկալի կամ անցանկալի։
Deref կամ DerefMut իրականացնող տիպերը սովորաբար կոչվում են «խելացի ցուցիչներ» (smart pointers), և deref coercion-ը նախագծվել է հատուկ այն ցուցիչանման վարքն աջակցելու համար, որը այս անունը ենթադրում է։ «Խելացի ցուցիչ» տիպը սովորաբար գոյություն ունի իր պարունակած արժեքի սեփականության իմաստաբանությունը (օր.՝ Rc կամ Cow) կամ պահպանման իմաստաբանությունը (օր.՝ Box) փոխելու համար։
Հիմնական հարցն այն է, թե արդյոք coercion-ը ցանկալի է ադապտերի համար։ Փաստաթղթավորման ստանդարտ օրինակը խելացի ցուցիչներն են։ Դժվար է ադապտերը խելացի ցուցիչ համարել. պահպանման իմաստաբանությունը այստեղ ոչ մի կապ չունի։ Այդուհանդերձ, փաստաթղթավորումը խիստ արգելո՞ւմ է Deref օգտագործել այն բաների վրա, որոնք խելացի ցուցիչներ չեն։
Անձամբ ես բավականին հաճախ եմ իրականացնում Deref և DerefMut trait-երը իմ ադապտերի տիպերի համար, հատկապես սեփականատեր ադապտերների։ Դա միշտ կախված է նրանից, թե ինչպես եմ մտադիր օգտագործել ադապտերը։ Եթե դա կարճակյաց ad hoc տիպ է, որը ստեղծում եմ ինչ-որ scope-ում միայն մի քանի trait մեթոդ կանչելու համար, կարող եմ Deref-ը բաց թողնել։ Մյուս կողմից, ես հաճախ կառուցում եմ մեկ ադապտեր իմ լուծման կենտրոնական տիպի համար՝ իրականացնելով բացակայող trait-երի մի ամբողջ հավաքածու, ապա օգտագործում եմ այդ տիպը գրեթե ամենուր՝ ադապտացվածի փոխարեն. այդ դեպքում կարող եմ սահմանել և՛ Deref, և՛ DerefMut՝ coercion-ի միջոցով բնօրինակ տիպի իրականացումը պահպանելու համար, ինչը սովորաբար հենց այն է, ինչ ուզում եմ։
Եթե Deref իրականացնելը ձեզ համար իդիոմներից չափազանց ուժեղ շեղում է թվում, այլընտրանքն է իրականացնել AsRef և հնարավոր է AsMut trait-երը՝ բնօրինակ օբյեկտին ըստ պահանջի հասանելիություն պահպանելու համար։ Այդ trait-երի թերությունն այն է, որ նրանք generic են, և երբեմն պետք է բացահայտ նշել, թե որ տիպին եք ուզում coerce անել։
Մեկ այլ տարբերակ է ադապտերի տիպի վրա առաջարկել ֆունկցիա, որը ուղիղ հասանելիություն է տալիս ներքին տիպին՝
impl<'a> ApplicatorAdapter<'a> {
fn as_inner(&self) -> &'a Multiplicator {
self.0
}
}
Փոփոխվող հղում վերադարձնող մեթոդի ավանդական անունը (փոփոխվող հղումով կամ սեփականատեր ադապտերների համար) as_inner_mut է։
Axum-ի խնդրի լուծումը ադապտերով
Վերադառնանք իմ հանդիպած գործնական խնդրին՝ axum-ը eyre crate-ի հետ կապելուն։ Axum-ն առաջարկում է axum::response::IntoResponse trait-ը, որը շատ կուզենայինք իրականացված տեսնել մեր լուծումում օգտագործվող սխալների տիպերի համար. իմ դեպքում դա eyre::Report-ն էր։ Orphan rule-ը, սակայն, մեզ արգելում է axum-ի trait-երը իրականացնել eyre տիպի համար։ Adapter օրինակը թույլ է տալիս շրջանցել դա՝
struct ErrorAdapter(eyre::Report);
impl axum::response::IntoResponse for ErrorAdapter {
fn into_response(self) -> axum::response::Response {
(
axum::http::StatusCode::INTERNAL_SERVER_ERROR,
"Internal server error",
).into_response()
}
}
Կանչի վայրում հարմարավետության համար կարող ենք իրականացնել From, ինչը թույլ է տալիս ? օպերատորը աշխատել ուղղակիորեն handler-ներում՝
impl From<eyre::Report> for ErrorAdapter {
fn from(e: eyre::Report) -> Self {
ErrorAdapter(e)
}
}
async fn my_handler() -> Result<impl IntoResponse, ErrorAdapter> {
let data = fetch_data().await?; // eyre::Report converts into ErrorAdapter via From
Ok(axum::Json(data))
}
Մի քանի ադապտեր trait-տիպ զույգի վրա
Մեր axum-eyre սխալների կամրջի մեկ խնդիր կա։ Մեր վերադարձրած յուրաքանչյուր սխալ դառնում է 500։ Դա, հավանաբար, ամենաողջամիտ լռելյայնն է, բայց երբեմն մեզ ավելի կոնկրետ տեսակի սխալ է պետք։ Դրան կարող ենք հասնել՝ մեր eyre սխալի տիպի համար սահմանելով մի քանի ադապտեր՝
struct ErrorAdapter404(eyre::Report);
impl axum::response::IntoResponse for ErrorAdapter404 {
fn into_response(self) -> axum::response::Response {
(
axum::http::StatusCode::NOT_FOUND,
"Resource not found",
).into_response()
}
}
struct ErrorAdapter403(eyre::Report);
impl axum::response::IntoResponse for ErrorAdapter403 {
fn into_response(self) -> axum::response::Response {
(
axum::http::StatusCode::FORBIDDEN,
"Forbidden resource",
).into_response()
}
}
trait ErrExt {
fn err500(self) -> ErrorAdapter;
fn err404(self) -> ErrorAdapter404;
fn err403(self) -> ErrorAdapter403;
}
impl ErrExt for eyre::Report {
fn err500(self) -> ErrorAdapter { self.into() }
fn err404(self) -> ErrorAdapter404 { ErrorAdapter404(self) }
fn err403(self) -> ErrorAdapter403 { ErrorAdapter403(self) }
}
Նկատեք, որ այժմ կարող ենք կա՛մ պարզ ? օգտագործել՝ Into սխալի փոխակերպմանը հենվելու համար, կա՛մ կանչել my_result.map_err(ErrExt::err404)՝ ներքին սխալը 404 ադապտերի մեջ փաթաթելու համար։ Extension trait-երով, սակայն, կարող ենք ավելի առաջ գնալ. ընդլայնելով result տիպը, որպեսզի API-ն էլ ավելի հարմար լինի։
trait ResultExt {
type Ok;
fn or500(self) -> Result<Self::Ok, ErrorAdapter>;
fn or404(self) -> Result<Self::Ok, ErrorAdapter404>;
fn or403(self) -> Result<Self::Ok, ErrorAdapter403>;
}
Մենք դեռ կարող ենք օգտագործել ?, երբ ուզում ենք 500 սխալ հաղորդել, բայց կարող ենք նաև պարզապես կանչել my_result.or404()?՝ սխալը 404 սխալներ վերադարձնելուն նվիրված ադապտերի վերածելու համար։
Հնարավոր է նաև ավելի ամուր լուծում. գուցե սխալի կոդը կարելի է ներարկել մասնագիտացված ադապտերի մեջ, որպեսզի սխալի յուրաքանչյուր կոդի համար առանձին տիպ պետք չլինի։ Մեկ այլ տարբերակ կլինի սխալի կոդի trait-երն օգտագործել որպես marker տիպեր ErrorAdapter-ի համար՝ trait-ի associated constant-ի տեսքով տրամադրելով միայն սխալի կոդը։ Սրանք, սակայն, նույն ադապտերային գաղափարի հետագա զարգացումներ են, ուստի կենտրոնացած մնալու համար թողնում եմ դրանք որպես բարելավման գաղափարներ՝ առանց հետագա ուսումնասիրության։
Ադապտերի այլընտրանքներ. trait crate-երի օգտակար միջոցներ
Նկատեք, որ adapter օրինակը միշտ անհրաժեշտ չէ Orphan Rule-ի սահմանափակումները շրջանցելու համար։ Երբեմն գոյություն ունեն այլ ելքեր։ serde crate-ը լավ օրինակ է։ Երբ օգտագործում ենք արտաքին crate-ի տիպ, որն իրականացված չունի serde-ի Serialize և Deserialize trait-երը, կարող ենք գայթակղվել գրել ադապտերի տիպ, որը դրանք իրականացնում է։ Սակայն դա պետք չէ։ Serde-ի հեղինակները գիտակցել են, թե որքան տարածված է այս իրավիճակը, և ավելացրել են հատուկ remote շարահյուսություն, որը մեզ համար լուծում է խնդիրը։
Վերևում քննարկված առաջին օրինակում Multiplicator տիպը serde-ի տիպերը չէր իրականացնում։ Serde-ն առաջարկում է հատուկ մեխանիզմ՝ այդպիսի տիպերի սերիալիզացիան պատվիրակելու համար, մեզ ազատելով Serialize կամ Deserialize ձեռքով իրականացնելուց, ինչը հաճախ բարդ է՝
#[derive(Serialize, Deserialize)]
#[serde(remote = "crate2::Multiplicator")]
struct MultiplicatorDef {
pub scale: u32,
}
#[derive(Serialize, Deserialize)]
struct Wrapper {
#[serde(with = "MultiplicatorDef")]
multiplicator: Multiplicator,
}
Remote շարահյուսությունը խիստ կոնկրետ է serde-ին և օգտակար է ոչ միայն այլ crate-երի տիպերի համար serde trait-եր իրականացնելու համար, բայց դա դուրս է այս հոդվածի շրջանակից։ Այն, ինչ ուզում եմ նշել, այն է, որ նախքան orphan rule-ը շրջանցելու համար adapter օրինակին դիմելը, լավ սովորություն է ստուգել՝ trait-ը սահմանող crate-ը առաջարկո՞ւմ է հատուկ շարահյուսություն, որն օգնում է ավելի համահունչ ձևով։
Հանրային թե՞ մասնավոր
Կա ևս մեկ կողմ, որին դեռ չեմ անդրադարձել և որը վեճի թեմա է եղել newtype օրինակների շուրջ։ Արդյո՞ք տիպի միակ դաշտը պետք է հանրային լինի, թե՞ մասնավոր։
Մաքուր newtype օրինակից տարբերվ, ներքին իրականացման տիպը թաքցնելը այն խնդիրը չէ, որը փորձում ենք այստեղ լուծել։ Հաշվի առնելով դա՝ հաճախ դաշտը մասնավոր դարձնելու իրական պատճառ չկա։ Սակայն մեկ այլ հարց է առաջանում. արդյո՞ք .0-ն լավ API է շրջանառության մեջ դնելու համար։ Ես անձամբ չեմ սիրում այն, և երբ իմ ադապտերների համար օգտագործում եմ մեկ դաշտով tuple struct-եր, սովորաբար դաշտը պահում եմ մասնավոր և բացահայտում Deref trait-ի կամ հատուկ մեթոդի միջոցով։
Մյուս կողմից, եթե ամեն դեպքում լրացուցիչ մեթոդ ենք ավելացնում, գուցե ավելի լավ է միակ դաշտը դարձնել անվանված դաշտ՝ tuple struct օգտագործելու փոխարեն։ ApplicatorAdapter-ը կարելի է վերափոխել հետևյալի՝
struct ApplicatorAdapter {
pub inner: Multiplicator,
}
Պայմանով, որ հիմքում ընկած տիպը թաքցնելու այլ պատճառներ չկան, ես այս մոտեցումը համարում եմ իդիոմատիկ։ Հաճախ դա ճաշակի հարց է, ինչպես նաև այն կոնկրետ հանգամանքների, որոնցում տիպն օգտագործվում է։ Այսպես, իմ տեսակետը հետևյալն է. հենց ադապտերի համար տեսանելիությունը մի բան չէ, որի համար պետք է անհանգստանալ։
Ամփոփում
Այս հոդվածում մենք քննեցինք newtype-like օրինակի ևս մեկ կիրառություն՝ ադապտերը։ Այն հատկապես հարմար է Rust-ում՝ ավելի, քան մյուս լեզուներում, քանի որ trait-երն ու տիպերը օրթոգոնալ են, և դրանից բխող Orphan Rule-ի պատճառով։
Հիմնական դասն այն է, որ ադապտերը ունիվերսալ լուծում է։ Serde-ն ունի remote, որոշ crate-եր տրամադրում են feature flag-եր crate-երի միջև trait-երի իրականացման համար, բայց երբ նման բան հասանելի չէ, ինչը հաճախ է պատահում, ադապտերը հիանալի գործիք է։ Սա տեսանք axum-ի և eyre-ի օրինակով. երկու հանրաճանաչ crate-եր, որոնք ոչինչ չգիտեն միմյանց մասին և ներկառուցված կամուրջ չեն առաջարկում։
Մենք նաև դիտարկեցինք, թե ինչպես դարձնել ադապտերները հարմար։ Մերկ ադապտերի տիպն ինքնին կարող է անհարմար թվալ, բայց extension trait-երի, From իրականացումների և մտածված API դիզայնի շնորհիվ նրանք գրեթե անտեսանելի են դառնում կանչի վայրում։ Օրինակը սահուն մասշտաբվում է մեկ trait-տիպ զույգից մինչև մի քանի մասնագիտացված ադապտեր, ինչպես ցույց տվեցին HTTP սխալների կոդերի տարբերակները։
Հաջորդ հոդվածում մենք ավելի մոտիկից կքննենք extension trait-երը՝ օրինակ, որը մենք արդեն օգտագործել ենք այստեղ ադապտերները հարմար դարձնելու համար, բայց որը, որպես հզոր Rust իդիոմ, արժանի է սեփական ուշադրության կենտրոնին։