Գնահատել նախագիծը
← Բոլոր հրապարակումները

Rust-ի նմուշները խորությամբ, հ. 1. Newtype-երը Rust-ում

Rust ծրագրավորման լեզվի Newtype նմուշի խորը տեխնիկական դիտարկում։ Հոդվածը քննում է, թե սեմանտիկ առումով ինչպես են newtype-երը տարբերվում type alias-ներից, և բացատրում է, թե ինչպես կարող են մասնավոր դաշտերով փաթաթիչները ապահովել տիրույթի ինվարիանտները։ Այն ընդգրկում է newtype-երը որպես ռեսուրսների handler-ներ գրաֆային կառուցվածքների համար, typestate նմուշի կիրառումը տվյալների վալիդացիայի համար (օրինակ՝ Email և Filter տիպերը) և իրականացման մանրամասները թաքցնելու եղանակները՝ semver-ի հետ համատեղելի մնալու համար։ Այն նաև զգուշացնում է բնորոշ թակարդների մասին, ինչպիսիք են սերիալիզացիայի ժամանակ «թաքնված փոխակերպումները» և պարզ տվյալների կառուցվածքներում ավելորդ boilerplate-ը։

16 րոպե
RustԾրագրավորման լեզուներԼավագույն փորձ

Newtype-երը, հավանաբար, Rust ծրագրավորման լեզվում օգտագործվող ամենապարզ նմուշն են՝ այնքան պարզ, որ այն նմուշ անվանելը չափազանցություն է, բայց կան որոշակի իրավիճակներ, որտեղ այն շատ օգտակար է ստացվում։ Միևնույն ժամանակ, այն հեշտ է չարաշահել, ինչը հանգեցնում է փոքր-ինչ չափազանց խոսուն կոդի։ Եկեք նայենք նմուշին և մտածենք, թե որտեղ է այն առավել տեղին։

Ի՞նչ են newtype-երը

Ըստ էության, newtype-ը մեկ դաշտով կառուցվածք է, որը փաթաթում է ինչ-որ հիմքում ընկած տիպ.

struct Handler(usize);

Սա սահմանում է Handler newtype, որը ներսում պահում է usize։ Ինձ համար սա շատ բնորոշ դեպք է. երբ ունեմ հիմքում ընկած վեկտոր և չեմ ուզում այն ինդեքսավորել մերկ usize-ով, ստեղծում եմ Handler փաթաթիչ։

Արժե նշել, թե ինչպես են newtype-երը տարբերվում type alias-ներից։ Հետևյալը newtype չէ.

type OtherHandler = usize;

OtherHandler-ը պարզապես usize-ի alias է։ Վճռորոշ տարբերությունն այն է, որ newtype-ը իրոք ներմուծում է նոր տիպ, մինչդեռ type հիմնաբառը զուտ տալիս է գոյություն ունեցող տիպին այլ անուն։ Արդյունքում այս օրինակում OtherHandler-ը և usize-ը փոխարինելի են, մինչդեռ Handler-ը լիովին առանձին տիպ է.

fn takes_handler(handler: Handler) {}
fn takes_usize(handler: usize) {}

fn main() {
    let raw = 0usize;
    let handler = Handler(0);
    // Note that I just assign an `usize` - its the exact same type
    let other_handler = 0usize;
    // Following would not compile, `Handler` is *not* an `usize`
    // let handler2 = 0usize;

    takes_usize(raw);
    // `takes_usize` accepts `OtherHandler`
    takes_usize(other_handler);
    // But doesn't accept `Handler`
    // takes_usize(handler);

    // `takes_handler` accepts `Handler` only
    takes_handler(handler);
    // Passing `usize` or `OtherHandler` fails
    // takes_handler(raw);
    // takes_handler(other_handler);
}

Type alias-ների և newtype-երի միջև ձևական տարբերությունը հստակ լինելուց հետո անդրադառնանք API-ի մեկ այլ կողմին՝ ներքին դաշտի հերմետիզացմանը։ Արդյո՞ք newtype-ի միակ դաշտը պետք է լինի հանրային։ Տեխնիկապես երկու ընտրությունն էլ վավեր է, բայց անձամբ ես newtype անվանումը վերապահում եմ այն տիպերին, որոնց դաշտը մասնավոր է։ Պատճառը թաքնված է նրանում, թե ինչի համար են newtype-երը։ Այս նմուշին դիմում ենք, երբ տեխնիկապես մեզ պետք է հիմքում ընկած տիպով կրվող տեղեկատվությունը, բայց այն օգտագործում ենք API-ին հատուկ սեմանտիկայով և չենք ուզում, որ հիմքում ընկած տիպը ուղղակիորեն փոխանցվի։

Այս տրամաբանությանը հետևելով՝ երբ newtype-ի դաշտը հանրային է, հիմքում ընկած տիպն ունեցող API օգտագործողը կարող է այն ուղիղ փոխանցել ֆունկցիային, ինչը քիչ թե շատ խաթարում է newtype-երի իմաստը։ Օրինակ՝

struct PubHandler(pub usize);

fn takes_pub_handler(handler: PubHandler) {}

fn main() {
    let raw = 0usize;
    let handler = PubHandler(0);

    takes_pub_handler(handler);
    // Passing `usize` fails
    // takes_pub_handler(raw);
    // But there is nothing stopping us to just create it in-place
    take_pub_handler(PubHandler(raw));
}

Այսպիսի newtype-ը մի փոքր բացահայտ աղմուկ է ավելացնում, ինչը կարող է հենց այն լինել, ինչ մեզ պետք է, բայց իմ կարծիքով այն հիմնականում ծառայում է այլ կիրառությունների։ Այդ իսկ պատճառով ես անձամբ հանրային դաշտերով տիպերն անվանում եմ wrapper տիպեր, իսկ մասնավոր դաշտերով տիպերը՝ newtype-եր։ Սա համընկնում է նաև Rust by Example-ին հետևող ընդհանուր պայմանավորվածությանը։ Հիշեք, որ սա ավելի շատ իդիոմատիկ ուղեցույց է. Rust էկոհամակարգում կարող եք տեսնել, որ ինչն ես անվանում եմ «wrapper տիպեր», կոչվում է «newtype-եր»։

Ինչո՞ւ օգտագործել newtype-եր

Ինչպես արդեն ասացի, newtype-երի ամենապարզ կիրառությունը հիմքում ընկած տիպով ներկայացված տեղեկատվությունը փոխանցելն է, բայց այլ սեմանտիկայով։ Քանի որ իմաստը տարբեր է, սովորաբար չենք ուզում, որ հիմքում ընկած տիպի ցանկացած արժեք ընդունվի. մենք ուզում ենք դրա նկատմամբ որոշակի վերահսկողություն։

Երկու ամենահաճախակի կիրառությունները.

  1. Ընդունել միայն այն արժեքները, որոնք մենք ինքներս ենք ավելի վաղ ստեղծել։
  2. Արժեքին կցել վալիդացիա։

Բավականին հաճախ ուզում ենք երկուսն էլ. մեր API-ի վերադարձրած արժեքները սկզբից ճիշտ են, և դեռ կարող ենք առաջարկել newtype-ը հիմքում ընկած տիպից կառուցելու եղանակ՝ լրացուցիչ վալիդացիայով։

Կիրառություն. newtype-ը որպես ռեսուրսների handler-ներ

Ամենապարզ newtype օրինակը, որ մի քանի անգամ օգտագործել եմ, վերևում ցույց տրված Handler տիպն է։ Ենթադրենք՝ գրադարան ենք կառուցում, որը ներսում պահպանում է գրաֆ, թերևս՝ հաշվարկային գրաֆ։ Գրաֆը ներկայացնելու ամենատարածված եղանակներից մեկը հանգույցները կոնտեյների մեջ պահելն է և նրանց միջև կապերը ներկայացնելու որևէ միջոց ավելացնելը՝ հնարավոր է՝ առանձին կոնտեյներներում։

Այսպիսի ներկայացմամբ GraphNode-ը կարող է բավականին ծախսատար կառուցվածք լինել, որը չէինք ուզենա շրջանառել։ Փոխարենը կարող էինք օգտագործել Rc<GraphNode>, բայց հաճախ պարզ մոտեցումը հանգույցների վեկտոր պահելն է և ամբողջ հանգույցի փոխարեն փոխանցել նրա ինդեքսը.

struct MyGraph {
    nodes: Vec<GraphNode>,
}

impl MyGraph {
    fn create_node(&mut self) -> usize {
        nodes.push(GraphNode::default());
        nodes.len() - 1
    }
}

Հետո, երբ ուզում ենք հանգույցների հետ ինչ-որ բան անել, փոխանցում ենք նրանց ինդեքսները.

impl MyGraph {
    fn add_connection(&mut self, from: usize, to: usize) {
        self.nodes[from].add_connection(to)
    }
}

Սա հիանալի աշխատում է, բայց թերությունն այն է, որ օգտատերը կարող է API-ին կամայական թվեր տալ, ինչը կարող է խնդիրների հանգեցնել՝ այս դեպքում, ամենայն հավանականությամբ, panic-ի.

fn main() {
    let mut graph = MyGraph::default();
    let node1 = graph.create_node();
    let node2 = graph.create_node();

    // All is fine
    graph.add_connection(node1, node2);

    // Here we get a panic
    graph.add_connection(100, 200);
}

Սա գուցե աղետալի չէ. Rust-ը կապահովի, որ անվավեր ինդեքսներին հասանելիություն չլինի, իսկ փաստաթղթերում միշտ կարելի է նշել, որ create_node մեթոդի կողմից նախկինում չվերադարձված ինդեքսները երբեք չպետք է փոխանցվեն։

Այնուամենայնիվ, կարող ենք ավելի լավ անել և անվավեր ինդեքսների ստեղծումը դարձնել անհնար.

struct NodeHandler(usize);

impl MyGraph {
    fn create_node(&mut self) -> NodeHandler {
        let index = self.nodes.len();
        self.nodes.push(GraphNode::default());
        NodeHandler(index)
    }

    fn add_connection(&mut self, from: NodeHandler, to: NodeHandler) {
        self.nodes[from.0].add_connection(to.0)
    }
}

Կոդը գրեթե նույնն է, ինչ առաջ, բայց կանխում է որոշակի խնդիրներ։ Սակայն կարելի է հարցնել՝ ինչո՞ւ որևէ մեկը կփոխանցի արժեք, որը մենք երբեք չենք վերադարձրել։ Գուցե ենթադրել են, որ արժեքները կարելի է անվտանգ պահել տվյալների բազայում, ապա վերականգնել և նորից օգտագործել, ինչը այդպես չէ։ Քիչ հավանական է, որ որևէ մեկը ուղիղ փոխանցի 100-ը որպես հանգույցի ինդեքս, բայց ուրիշից ստացված արժեքի անվավեր դառնալը բավականին հավանական սխալ է։

Շատ զգույշ եղեք ստացած արժեքների վերաբերյալ ցանկացած լրացուցիչ ենթադրության հարցում։ Այս օրինակում add_connection մեթոդը կարող է ենթադրել, որ from և to պարամետրերը MyGraph-ի ստեղծած հանգույցներ են, բայց չի կարող անվտանգ ենթադրել, որ դրանք գալիս են MyGraph-ի նույն օրինակից։ Դիտարկենք հետևյալ օրինակը.

impl MyGraph {
    fn add_connection(&mut self, from: NodeHandler, to: NodeHandler) {
        unsafe {
            self.nodes.get_unchecked(from.0).add_connection(to.0)
        }
    }
}

Գայթակղիչ է մտածել, որ քանի որ մենք NodeHandler-ի միակ արտադրողն ենք, կարող ենք լիովին վստահել դրան և կիրառել սահմանների ստուգումը բաց թողնելու վճռորոշ օպտիմիզացիան։ Սակայն բավականին հեշտությամբ կարող ենք հայտնվել անհիմն (unsound) կոդի մեջ.

fn main() {
    let graph1 = MyGraph::default();
    let graph2 = MyGraph::default();
    let node1 = graph1.create_node();
    let node2 = graph2.create_node();
    let node3 = graph3.create_node();
    // `node3` index here is `1`, and the `self.nodes.get_unchecked(1)` becomes an unsound call
    graph1.add_connection(node3, node2);
}

Եթե այս օպտիմիզացիան իրոք կարևոր լիներ, այն կարելի էր իրականացնել, բայց դա կպահանջեր լրացուցիչ ինստրումենտացիա lifetime-ներով։

Այսպիսի սցենարում Newtypes-ը սովորաբար կօգներ ապահովել մշակողին հարմար API, բայց հազվադեպ կօգներ արտադրողականության օպտիմիզացիաների հարցում։

Տիպերի վալիդացիա

Newtype-երի երկրորդ կիրառությունը վերջերս առաջ եկավ մեր ընկերության Book Club-ում։ Սկզբում փոքր-ինչ թերահավատ էի, բայց կարծում եմ՝ դա պայմանավորված էր այն բանով, որ այդ թեմային մոտեցվել էր Rust-ի համար ոչ շատ բնորոշ տեսանկյունից։ Այնուամենայնիվ, սա newtype-երի շատ տարածված կիրառություն է Rust ծրագրավորման լեզվում։

Նախորդ օրինակում newtype-երը երաշխավորում էին, որ գրաֆի հանգույցի handler-ը ստեղծվել է մեր crate-ի կողմից և ոչ թե ինչ-որ պատահական usize արժեք է, որ սնվել է մեր համակարգին։ Newtype-երի մեկ այլ դեպք նման է. մենք ուզում ենք սահմանափակել ֆունկցիային փոխանցվող արժեքները, բայց դրանք պարտադիր չէ լինեն մեր նախկինում ստեղծածները։ Գուցե ուզում ենք միայն համոզվել, որ արժեքն անցել է որոշակի մշակում, և այդ մշակումը հաճախ վալիդացիան է։

Ահա իրական կյանքի օրինակ։ Ասենք՝ շախմատային գործիք ենք կառուցում, որը ֆիլտրում է խաղերը։ Ֆիլտրի օբյեկտը կունենար հետևյալ տեսքը.

struct Filter {
    pub player: Option<String>,
    pub color: Option<Color>,
}

impl ChessService {
    fn fetch_games(&self filter: Filter) -> Vec<Game> {
        todo!()
    }
}

Filter կառուցվածքը նկարագրում է, թե ինչպես են խաղերը ֆիլտրվում։ Պարզեցված տարբերակում մեզ պետք են միայն տվյալ խաղացողի խաղերը։ Բացի այդ, եթե գույնը սահմանված է, ստանում ենք միայն այն խաղերը, որոնք այդ խաղացողը խաղացել է տվյալ գույնով։

Այն հիմնական ենթադրությունը, որ կուզենայինք պահպանել Filter կառուցվածքի համար, հեշտ է նկատել. color դաշտը հավանաբար երբեք չպետք է սահմանված լինի, երբ player-ը None է։ Սա լուծելու եղանակներից մեկը ֆիլտրը fetch_games մեթոդի ներսում վալիդացնելն է.

impl ChessService {
    fn fetch_games(&self, filter: Filter) -> Vec<Game> {
        if filter.player.is_none() && filter.color.is_some() {
            panic!("Invalid filter: color cannot be set without player");
        }
        todo!()
    }
}

Աշխատում է, բայց կա մի փոքր խնդիր. եթե նույն ֆիլտրը մի քանի անգամ փոխանցվի fetch_games-ին կամ այլ մեթոդների, այն պետք է ամեն անգամ վալիդացվի։ Արտադրողականության արժեքը մեծ չէ, բայց դա աշխատանք է, որից հեշտ է խուսափել։ Newtype նմուշը սա լուծում է.

struct ValidatedFilter(Filter);

impl ValidatedFilter {
    fn new(filter: Filter) -> Self {
        if filter.player.is_none() && filter.color.is_some() {
            panic!("Invalid filter: color cannot be set without player");
        }
        Self(filter)
    }
}

impl ChessService {
    fn fetch_games(&self, filter: ValidatedFilter) -> Vec<Game> {
        todo!()
    }
}

Այժմ վալիդացիան տեղի է ունենում միայն մեկ անգամ՝ ֆիլտրը ստեղծելիս, և համակարգի մնացած մասը կարող է այն դիտարկել որպես վավեր։ Ի տարբերություն նախորդ դեպքի՝ այստեղ կարող ենք նույնիսկ մի փոքր արտադրողականություն շահել, քանի որ վալիդացիան կախված չէ որևէ այլ սուբյեկտից։

Իհարկե, newtype-ն այստեղ խստորեն պարտադիր չէ. ValidatedFilter կառուցվածքը կարող էր պարունակել նաև Filter-ի բոլոր դաշտերը, բայց դա կնշանակեր կոդի կրկնօրինակում։

Newtype-ի այս կիրառությունը կարելի է դիտել որպես typestate նմուշի հիմնական կիրառություն։ Typestate նմուշը տարածված է Rust-ում. գաղափարը տիպային համակարգն օգտագործելն է օբյեկտի վիճակը արտահայտելու համար։ Այստեղ Filter տիպը պոտենցիալ ֆիլտր է, որը դեռ կարող է կառուցման փուլում լինել, իսկ ValidatedFilter տիպը validated վիճակում գտնվող ֆիլտրն է։ Սա նաև հաճախ համակցվում է builder-ների հետ. Filter-ը կծառայեր որպես builder՝ թերևս դաշտերը սահմանելու մեթոդներով, իսկ վերջնական Filter::build(self) մեթոդը կկատարեր վալիդացիան և կվերադարձներ պատրաստի ValidatedFilter։

Վալիդացիայի համար newtype օգտագործելու ևս մեկ օրինակ է Email տիպը այն համակարգում, որտեղ մեզ պետք է, որ email-ները վավեր լինեն, և գուցե նաև ուզում ենք ֆիլտրել թույլատրելի դոմեյնները կամ կիրառել մերժման ցուցակներ։ Նույնիսկ email-ի հիմնական վալիդացիան բավականին բարդ է, և որոշ համակարգերում այն կարող է կամայականորեն բարդանալ։

Թեև դժվար է պատկերացնել, թե ինչպես email-ի վալիդացիայի արտադրողականությունը կազդի email-ի ձևաչափից կախված համակարգի վրա, ես հեշտությամբ կարող եմ պատկերացնել համակարգ, որի կայունությունն իսկապես կախված է այդ ձևաչափից։ Եվ ահա մի բան, որ սովորել եմ. եթե կոմպիլյատորը ինչ-որ բան չի ստուգում, ուշ թե շուտ ես դա կմոռանամ անել, կամ իմ թիմից որևէ մեկը կմոռանա։ Կոդը կունենա այսպիսի տեսք.

struct Email(String);

impl Email {
  fn validate(str: String) -> Result<Self, ValidationError> {
    // Validation code...

    Self(str)
  }
}

Newtype նմուշը օգնում է ապահովել, որ երբեք բաց չթողնենք email-ի վալիդացիան. email-ի իրական ձևաչափից կախված ցանկացած կոդ պետք է միշտ օգտագործի newtype-ը։ Այն կոդը, որը email-ը մշակում է որպես String կամ &str, նորմալ է, քանի դեռ այդ հատվածը ձևաչափից կախված չէ։

Նաև նկատեք, որ այս դեպքում կարող է օգտակար լինել տողի փոխակերպող ֆունկցիաներ ավելացնելը. գուցե From փոխակերպում (բայց միայն Email-ից String, երբեք՝ հակառակը), գուցե AsRef կամ նույնիսկ Deref trait, որը բացահայտում է ներքին տողը։ Email-ը նորից String դարձնելը խնդիր չի առաջացնում. նույնիսկ եթե այն փոփոխվի կամ մշակվի՝ նախքան համակարգի կրիտիկական մասին հասնելը, պատշաճ email դառնալու համար այն նորից պետք է վալիդացվի։

Կարող ենք էլ ավելի հեռու գնալ՝ այս newtype-ն ավելի հարմար դարձնելու համար։ TryFrom trait-ը թույլ է տալիս իրականացնել String-ից Email-ի փոխակերպում, և դա ուղիղ, չստուգվող փոխակերպում չէ։ Քանի որ փոխակերպումը կարող է ձախողվել, մենք հնարավորություն ենք ստանում վալիդացիա կատարել.

impl TryFrom<String> for Email {
  type Error = ValidationError;

  fn try_from(value: String) -> Result<Self, Self::Error> {
    Self::validate(value)
  }
}

Կարող ենք ավելացնել էլ ավելի շատ օգնականներ և թույլ տալ դեսերիալիզացիա ուղիղ Email-ի մեջ. պարզապես հիշեք, որ դա անելիս միշտ վալիդացիա կատարեք։ Դեսերիալիզացիայի համար serde օգտագործելիս պետք է գրենք սեփական դեսերիալիզացիայի իրականացում կամ օգտագործենք try_from serde ատրիբուտը։

Հիմքում ընկած տիպի թաքցում

Newtype նմուշն օգտագործելու ևս մեկ պատճառ կա, որը հատկապես արժեքավոր է գրադարաններ կառուցելիս՝ հիմքում ընկած տիպի լիակատար թաքցումը։ Մինչ այժմ մենք հիմնականում կենտրոնացել էինք հիմքում ընկած տվյալի արժեքի վրա և newtype-ը դիտարկում էինք հիմնականում որպես պահակ, որը անվավեր մուտքը դուրս է պահում մեր համակարգից։

Երբեմն, սակայն, կարող ենք ցանկանալ չբացահայտել հիմքում ընկած տիպը՝ API-ի ապագա փոփոխությունների համար որոշակի ճկունություն պահպանելու նպատակով։

Վերադառնանք գրաֆի օրինակին։ Ասացինք, որ գրաֆը բաղկացած է թաքնված վեկտորում պահվող GraphNode արժեքներից։ Սակայն ինչ-որ պահի կարող ենք ուզել փոխել այդ իրականացումը։ Թերևս վեկտորը կվերանա, և փոխարենը կօգտագործենք Rc<NodeData>։ Կամ գուցե ինչ-որ փուլում վեկտորը բավարար չի լինի, և մեզ պետք կգա HashMap<Uuid, GraphNode> կամ նույնիսկ տվյալների բազա, որտեղ usize-ը հարմար ինդեքսային տիպ չի լինի։

API գրադարանում newtype նմուշը օգտագործելով՝ մենք օգտատիրոջը տալիս ենք տիպ, որն արտահայտում է իր սեմանտիկան, այլ ոչ իրականացման մանրամասները։ Սա հեշտացնում է ամբողջ իրականացումը փոխարինելը առանց major տարբերակի բարձրացման՝ մնալով semver-ի հետ համատեղելի։

Newtype-ը միշտ լավագույն ընտրությո՞ւնն է

Մենք դիտարկեցինք երկու հիմնական իրավիճակ, որտեղ newtype նմուշը օգնում է ավելի լավ API ապահովել։ Ուրեմն հարցն այն է՝ պե՞տք է newtype-երը մղենք ամենուր, որտեղ թվում է, թե իմաստ ունեն։

Անձամբ ես դեմ եմ դրան։ Newtype-երը կարող են բարելավել API-ը, բայց նույնքան լավ boilerplate են ավելացնում։

Ահա օրինակ։ Ենթադրենք՝ գրաֆիկական գրադարան ենք գրում և ուզում ենք առաջարկել Color տիպ՝ այսպիսին.

struct Color(u8, u8, u8);

Color-ի երեք տարրերը RGB արժեքներն են՝ յուրաքանչյուրը 8-բիթանոց։ Բայց մենք շատ ոգևորված ենք newtype-երով, ուստի «բարելավում» ենք մեր API-ը.

struct Channel(u8);
struct Color(Channel, Channel, Channel);

impl Color {
    fn new(r: Channel, g: Channel, b: Channel) -> Self {
        Self(r, g, b)
    }
}

Խնդիրն այն է, որ այս կոնկրետ կիրառության համար մենք գրեթե անշուշտ կուզենանք թույլ տալ Channel կառուցել u8-ից և հակառակը.

impl From<u8> for Channel {
    fn from(value: u8) -> Self {
        Self(value)
    }
}

impl From<Channel> for u8 {
    fn from(value: Channel) -> Self {
        value.0
    }
}

Այժմ մեր crate-ի օգտագործողն իրոք կարող է կապույտ գույն ստեղծել.

fn main() {
    let blue = Color(Channel::from(0), Channel::from(0), Channel::from(255));
}

Into trait-ի դեպքում այն կարող է նույնիսկ ավելի գեղեցիկ երևալ.

fn main() {
    let blue = Color::new(0.into(), 0.into(), 255.into());
}

Սակայն անկեղծ ասած՝ այս շարահյուսության որևէ օգուտ չեմ տեսնում պարզ Color::new(0, 0, 255)-ի համեմատ։ Մենք boilerplate պահանջ ենք ավելացրել՝ առանց որևէ իմաստալից բան շահելու։

Newtype-եր օգտագործելու իմ մատնաչափի կանոնը. օգտագործեք, եթե չեք առաջարկելու կոնստրուկտոր, որը newtype-ը կառուցում է անմիջապես հիմքում ընկած տիպից՝ լինի մեթոդով, թե From trait-ով։ Եթե այդպես է, նշանակում է՝ արժեքի ձևի վրա կա որոշակի սահմանափակում, որը ստուգվում է տիպը վերադարձնելիս։ Սակայն նկատի ունեցեք, որ վալիդացիա կատարող կոնստրուկտորը այն չէ, ինչ ես նկատի ունեմ ուղիղ ստեղծում ասելով։ Այսպես՝ եթե կոնստրուկտորը fn ValidatedFilter::new(Filter) -> Result<Filter> է, դա լիովին newtype նմուշի դեպք է։

Տարածված թակարդ. թաքնված փոխակերպում

Թեմա, որը փորձում եմ անցկացնել ողջ այս հոդվածով, այն է, որ newtype-ը պետք է ապահովի իր ստեղծման վերահսկվածությունը։ Կա մի բնորոշ թակարդ, որ մի քանի անգամ տեսել եմ, երբ newtype-երն օգտագործվել են անզգույշ՝ թաքնված փոխակերպումը։

Ինչպես նշել էի գույնի օրինակում, newtype-երը երբեմն հանգեցնում են from / into կանչերի կույտերի, ինչը ինձ համար ազդանշան է, որ նմուշը չարաշահվում է։

Եվ թեև From trait-ը շատ բացահայտ փոխակերպում է, newtype-եր իրականացնելիս պետք է հատկապես զգույշ լինենք, որ ստեղծման յուրաքանչյուր ուղի՝ մասնավորապես փոխակերպումները, անցնի պատշաճ կառուցման միջով, որը պահում է տիպի համահունչությունը։ Սովորական վրիպումը վերաբերում է սերիալիզացիային։ Ես արդեն անդրադարձել եմ դրան Email օրինակում, բայց արժե կրկնել. կուրորեն մի դրեք #[derive(Deserialize)] ձեր newtype-երի վրա։ Այն կարող է լինել serde::Deserialize, բայց կծածկի դեսերիալիզացիայի ցանկացած կետ, որին կարող եք հանդիպել՝ ձեր արձանագրության իրականացումը, ձեր երկուական mmaping ալոկատորը։

Newtype-երի կիրառման շատ կոնկրետ հակաօրինակ գալիս է մի նախագծից, որը ես նախկինում պահպանում էի՝ CosmWasm։ Այն ունի մեկ հատուկ, շատ լայնորեն օգտագործվող տիպ՝ Addr։ Addr-ը վավեր Cosmos հասցեն ներկայացնող տողի վրա newtype է։ Այն լավ փաստաթղթավորված է և ստեղծվում է վալիդացիայի միջոցով, բայց ունի մեկ թերություն. այն կարելի է ուղիղ դեսերիալիզացնել։ Դրա համար շատ կոնկրետ պատճառներ կային, և չեմ ուզում խորանալ՝ դա հիմնավորված բացառություն է, թե ոչ։ Պատճառները հիմնականում վերաբերում էին նրան, որ տիպը հաճախ սերիալիզացվում և դեսերիալիզացվում է պահոցում. հաշվի առնելով CosmWasm-ի բնույթը՝ արտադրողականությունը կարևոր էր, ինչպես նաև վալիդացիան բաց թողնելը, երբ դա պետք չէր։

Սակայն կար մեկ դեպք, երբ Deserialize-ը իրական խնդիր առաջացրեց. Addr տիպը կարող էր անմիջականորեն օգտագործվել որպես մուտքային smart contract հաղորդագրության դաշտ։ Եվ այդպիսի հաղորդագրությունն ուներ մեկ առանձնահատկություն՝ այն գալիս էր չվստահվող օգտատիրոջից։ Այս փոքր վրիպումը հնարավոր էր դարձնում պատահաբար բաց թողնել հասցեի վալիդացիան, ինչը կարող էր տարատեսակ խափանումների հանգեցնել։ Չգիտեմ դրա պատճառով առաջացած որևէ կրիտիկական վրիպակի մասին, բայց հանդիպել եմ մի քանի իրավիճակների, երբ դրա պատճառով ժամանակ ենք կորցրել թեստավորման վրա. օրինակ՝ կոնֆիգուրացիայի սխալներ, որոնք կարելի էր վաղ բռնել, բայց փոխարենը հայտնվեցին որպես խոր սխալներ։

Խնդիրը լուծվեց ուղեցույցներով. փորձառու CosmWasm մշակողները գիտեն երբեք չդնել Addr-ը հաղորդագրությունների տիպերում հենց այս պատճառով։ Անցյալում նման բաներ ենք արել թվերի հետ. օրինակ՝ Wasm-ի իրականացման սահմանափակումները մեզ ստիպեցին խուսափել i128-ից։

Սա ընդամենը մեկ իրական օրինակ է, բայց այն ինձ արժեքավոր դաս տվեց newtype-երի հետ աշխատանքի մասին։

Վերջին խոսք

Newtype նմուշի հիմնական միտքը տիպի ստեղծման վերահսկումն է՝ անկախ պատճառից։ Օգտագործեք այն, երբ այն ձեզ տալիս է օգտակար, տիպով ստուգվող նախապայմաններ, և օգտագործեք զգուշությամբ։ Միշտ հիշեք վերանայել ստեղծման յուրաքանչյուր ուղի և վայելեք մաքուր, Rust-ային կոդային բազա։