تقدير المشروع
← كل المقالات

نمط المحوّل (Adapter) في Rust: الالتفاف على Orphan Rule باستخدام Newtypes وExtension Traits

يتناول هذا المقال نمط Adapter في Rust كطريقة عملية للتعامل مع Orphan Rule – القيد في اللغة الذي يمنع تنفيذ سمات (traits) خارجية لأنواع خارجية. يبدأ بشرح واضح لسبب وجود Orphan Rule والمشكلات التي يسببها عند الترجمة، ثم يبيّن خطوة بخطوة كيفية بناء محوّل قائم على newtype، وكيفية تحويله إلى محوّل يحمل مرجعًا بفترات حياة (lifetimes) صريحة، وكيفية تغليف كل ذلك في extension trait للحصول على واجهة برمجية نظيفة ومريحة. ويربط مثال واقعي بين مكتبتي axum وeyre، موضحًا كيف يمكن لعدة محوّلات متخصصة ربط الأخطاء برموز حالة HTTP معينة. كما يناقش المقال أسئلة تصميمية مثل تنفيذ Deref وAsRef، والحقول الداخلية العامة مقابل الخاصة، والحالات التي قد تناسب فيها خيارات الجهات الخارجية مثل صياغة remote في serde أكثر من محوّل مكتوب يدويًا.

15 دقائق قراءة
Rustلغة rustلغات البرمجة

دعونا أولًا نستذكر نمط Newtype في لغة البرمجة Rust. في هذا النمط، تُستخدم بنية (struct) من نوع tuple بحقل واحد إما لتغيير دلالات النوع الداخلي أو لإخفاء نوع التنفيذ عن المستخدم النهائي - وغالبًا ما نسعى إلى الأمرين معًا.

في هذا المقال، سنفحص مجددًا البنية ذات الحقل الواحد، لكننا سنستخدمها هذه المرة لتنفيذ نمط المحوّل (adapter). لنبدأ بوصف المشكلة التي صُمم لحلها.

Orphan Rule

من تجربتي، يُعد نظام الأنواع في Rust من أصعب الأمور فهمًا فهمًا حقيقيًا - لمجرد أنه يختلف كثيرًا عن اللغات كائنية التوجه التي اعتدنا عليها.

من الجوانب غير المألوفة فيه كيفية ارتباط السمات (Traits) بالأنواع التي يعرّفها المستخدم. تُقدَّم السمات عادةً على أنها تنفيذ للواجهات (interfaces). ولأن كليهما يؤدي دورًا متشابهًا - التجريد على مستوى السلوك - فإنني شخصيًا أتجنب وصف السمات بأنها واجهات بسهولة زائدة، لأن هناك فرقًا مهمًا بينهما. فنحن نعتبر الواجهات عادةً مرتبطة بنوع عند نقطة تعريف النوع. لذا عندما نعرّف النوع Orc، نسرد فورًا كل واجهة ينفذها - Creature, Foe, Mesh. أما السمات فلا تعمل هكذا. ففي Rust، السمات والأنواع متعامدة تمامًا وتُعرَّف بشكل مستقل عن بعضها. وبالنسبة للأنواع العامة، لا يمكنك أبدًا ادعاء معرفة كل سمة منفَّذة للنوع - فالحزم (crates) التابعة يمكنها دائمًا الإضافة إلى تلك المجموعة.

لكن هذا يخلق مشكلة. لنفترض أن لدينا حزمتين، 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 يريد مؤلفها استخدام الحزمتين ويحتاج إلى تنفيذ 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 على تنفيذها الخاص للسمة، وتعتمد crate4 على تنفيذها، وكل شيء على ما يرام. لكن الأمور تتعقد بمجرد إضافة crate5، التي تعتمد على كل الحزم المذكورة حتى الآن:

use crate1::Applicator;

fn main() {
 let m = crate2::Multiplicator { scale: 3 };
 println!("{}", m.apply(3));
}

والسؤال هنا: ماذا ستطبع crate5؟ 9 أم 27؟ لا توجد طريقة لمعرفة أي تنفيذ هو الصحيح!

إجابة محتملة واحدة: ببساطة نرفض الترجمة عند نشوء هذا الوضع! يمكن أن تتسبب crate5 في خطأ ترجمة بسبب تنفيذين متعارضين لـ Applicator للنوع Multiplicator. لكن ذلك قصير النظر. فربما لم تكن crate4 تحتاج إلى تنفيذ Applicator وقت كتابة crate5، وكانت الخطة الاعتماد على تنفيذ crate3 الموجود دائمًا. في تلك الحالة، ستُترجم الشيفرة بشكل سليم إلى أن تُدخل crate4 تنفيذها الجديد للسمة. وهذا ليس ما نريده - فهو يجعل إدارة الاعتماديات صعبة للغاية.

وبدلًا من ذلك، استقر مبتكرو Rust على ما يُعرف بـ Orphan Rule. صياغتها الكاملة معقدة إلى حد ما لأنها تغطي بعض الحالات التي تتضمن الأنواع العامة (generics)، لكن النسخة المبسطة التي أحب استخدامها هي:

لتنفيذ سمة لنوع ما، يجب أن تملك الحزمة التي تحتوي على كتلة impl السمةَ أو النوعَ.

والجزء الدقيق يتعلق بالأنواع العامة - فقد تبيّن أنه في تلك الحالات، يمكن أن يأتي كل من النوع العام والسمة من حزم خارجية، شريطة أن تملك الحزمة التي تحتوي على كتلة impl نوعًا يُستخدم لتخصيص النوع العام. وتُوصف القاعدة الكاملة في المرجع الخاص بـ Rust.

المشكلة

لنعد إلى 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 لخادم ويب. لدى axum السمة axum::response::IntoResponse، المقصود تنفيذها للأنواع التي يمكن تحويلها إلى استجابة HTTP. وخاصية مفيدة في هذه السمة هي أنه عندما تُنفَّذ axum::response::IntoResponse لكل من T وE، فإنها تُنفَّذ أيضًا لـ Result<T, E> - فكل ما نريده هو تنفيذ السمة لأنواع الأخطاء التي نعرّفها!

وبما أنني أبني تطبيقًا تنفيذيًا (binary) لا مكتبة، فإنني أفضّل حزمة eyre (أو anyhow) لمعالجة الأخطاء. وهنا المشكلة - axum لا تعرف أيًّا من هاتين الحزمتين. ولا تنفذ أي منهما سمات axum. لذا إذا أردت أن تنتج أخطاء eyre لدي استجابات HTTP بالرمز 500 فحسب، فأنا عالق - لا أستطيع ببساطة تنفيذ سمة! والحل المباشر هو نمط Adapter.

نمط Adapter

نمط المحوّل هو مجرد newtype، تمامًا كما اقترح المترجم، ينفذ السمات التي ينقصها نوعنا الخارجي. لنستخدمه لإصلاح 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 الآن، نبني المحوّل أولًا فحسب:

fn mul(a: u32, b: u32) -> u32 {
  let m = Multiplicator { scale: a };
  let adapter = ApplicatorAdapter::new(m);
  adapter.apply(b)
}

المرجع كنوع كامن

الحل أعلاه يعمل بالفعل. لكن له عيبًا كبيرًا: فبناء المحوّل يتطلب الملكية الكاملة لـ Multiplicator. ونتيجة لذلك، يصبح المحوّل عديم الفائدة إذا أردنا الاحتفاظ بالكائن الأصلي بعد ذلك، أو إذا لم يكن لدينا سوى مرجع (reference)، وهو ما ينبغي أن يكفي بالنظر إلى تعريف 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)، لأن كل مرجع يجب أن يُربط بفترة حياة ما. وهنا يضمن ذلك ألّا يعيش البنية ApplicatorAdapter أطول من Multiplicator الذي بُنيت منه أبدًا. وهذا منطقي؛ فالغلاف يحمل مرجعًا، فلو عاش أطول من Multiplicator الداخلي لانتهينا بمرجع معلّق (dangling reference) شديد الخطورة.

وتذكّر أنه لو تطلبت دالة في السمة Applicator القيمة &mut self، فسنستخدم ببساطة مرجعًا قابلًا للتعديل داخليًا. لكن ذلك سيكون مزعجًا إلى حد ما - فهو يعني الحاجة دائمًا إلى مرجع قابل للتعديل إلى الكائن، حتى لاستدعاء دوال &self في Applicator. وفي تلك الحالات، النهج المعتاد هو استخدام محوّل مالك وتوفير واجهة لتحويله مرة أخرى إلى الكائن الداخلي، مثل دالة fn into_inner(self) -> Multiplicator على نوع المحوّل.

Extension trait للإنشاء

التفّ نمط المحوّل على orphan rule، لكنه جلب مشكلة جديدة: أصبحت الواجهة البرمجية مزعجة. علينا بناء نوع جديد كامل لاستدعاء واحد، والاسم طويل، وهناك كثير من الأحرف للكتابة والقراءة. يمكننا اختصار اسم نوع المحوّل، لكن حتى حينها لا تعجبني الواجهة الناتجة.

العلاج المعتاد هو نمط آخر شائع جدًا في Rust - extension trait. فكرته تعريف سمة جديدة خاصة بالحزمة وتنفيذها للنوع المُحوَّل، مما يمنحه وظائف جديدة. ولن تقف orphan rule في طريقنا - فتعريف السمة لنا. وهكذا قد يبدو ذلك:

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 (deref coercion) ميزة قوية في اللغة لها عواقب واسعة النطاق على أي نوع ينفذ Deref. فالمترجم يُدرج استدعاءات Deref::deref بصمت. ولهذا يتطلب تنفيذ Deref الحذر وينبغي ألّا يتم إلا عندما يكون إكراه deref مرغوبًا. وتأتي أدناه إرشادات حول متى يكون ذلك مرغوبًا عادةً أو غير مرغوب.
يُشار عادةً إلى الأنواع التي تنفذ Deref أو DerefMut باسم «المؤشرات الذكية»، وقد صُمم إكراه deref تحديدًا لدعم السلوك الشبيه بالمؤشرات الذي يوحي به هذا الاسم. ويوجد نوع «المؤشر الذكي» عادةً لتغيير دلالات ملكية القيمة التي يحتويها (مثل Rc أو Cow) أو دلالات تخزينها (مثل Box).

السؤال الجوهري هو ما إذا كان الإكراه مرغوبًا في المحوّل. المثال القياسي في الوثائق هو المؤشرات الذكية. ومن الصعب اعتبار المحوّل مؤشرًا ذكيًا - فدلالات التخزين لا علاقة لها به. ومع ذلك، هل تحظر الوثائق صراحةً استخدام Deref على ما ليس مؤشرات ذكية؟

شخصيًا، أنفّذ السمتين Deref وDerefMut لأنواع المحوّلات لدي كثيرًا، خاصة المحوّلات المالكة. ويعتمد ذلك دائمًا على كيفية نيّتي استخدام المحوّل. فإذا كان نوعًا مؤقتًا قصير العمر أنشئه في نطاق ما فقط لاستدعاء بضع دوال سمات، فقد أستغني عن Deref. ومن ناحية أخرى، كثيرًا ما أبني محوّلًا واحدًا لنوع محوري في حلّي، فأنفذ مجموعة كاملة من السمات الناقصة، ثم أستخدم هذا النوع في كل مكان تقريبًا بدلًا من النوع المُحوَّل - وفي تلك الحالة قد أعرّف كلًّا من Deref وDerefMut للاحتفاظ بتنفيذ النوع الأصلي عبر الإكراه - وهو عادةً ما أريده تمامًا.

وإذا بدا لك تنفيذ Deref كسرًا شديدًا للأعراف، فهناك بديل هو تنفيذ السمتين AsRef وربما AsMut للاحتفاظ بوصول عند الطلب إلى الكائن الأصلي. وعيب هاتين السمتين أنهما عامتان (generic)، وأحيانًا عليك تحديد النوع الذي تريد الإكراه إليه صراحةً.

وهناك خيار آخر هو توفير دالة على نوع المحوّل تمنح وصولًا مباشرًا إلى النوع الداخلي:

impl<'a> ApplicatorAdapter<'a> {
  fn as_inner(&self) -> &'a Multiplicator {
    self.0
  }
}

والاسم المتعارف عليه لدالة تُرجع مرجعًا قابلًا للتعديل (للمحوّلات ذات المرجع القابل للتعديل أو المالكة) هو as_inner_mut.

حل مشكلة Axum بالمحوّل

لنعد إلى المشكلة العملية التي واجهتها – ربط axum بحزمة eyre. توفر Axum السمة axum::response::IntoResponse، التي نود كثيرًا تنفيذها لأنواع الأخطاء المستخدمة في حلّنا - وكان ذلك بالنسبة لي eyre::Report. لكن orphan rule تمنعنا من تنفيذ سمات axum لنوع من eyre. ويتيح لنا نمط المحوّل الالتفاف على ذلك:

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، مما يتيح للمعامل ? العمل مباشرة في المعالجات (handlers):

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))
}

محوّلات متعددة على زوج سمة-نوع

لجسر الأخطاء 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 traits، يمكننا المضي خطوة أبعد - بتوسيع نوع النتيجة (result) لجعل الواجهة أجمل!

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.

وقد يكون هناك حل أكثر متانة - ربما يمكن حقن رمز الخطأ في المحوّل المتخصص كي لا نحتاج إلى نوع منفصل لكل رمز خطأ. وخيار آخر هو استخدام سمات رموز الأخطاء كأنواع علامات (marker types) لـ ErrorAdapter، مع توفير رمز الخطأ فقط كثابت مرتبط (associated constant) بالسمة. لكن هذه تطويرات إضافية لفكرة المحوّل نفسها، لذا ولكي نبقى مركّزين سأتركها أفكارًا للتحسين دون استكشافها أكثر.

بدائل المحوّل - أدوات الحزم الخاصة بالسمات

لاحظ أن نمط المحوّل ليس ضروريًا دائمًا للالتفاف على قيود Orphan Rule. فأحيانًا توجد مخارج أخرى. وحزمة serde مثال جيد. فعندما نستخدم نوعًا من حزمة خارجية لا ينفذ سمتي Serialize وDeserialize الخاصتين بـ serde، قد نُغرى بكتابة نوع محوّل ينفذهما. لكن ذلك غير ضروري. فقد أدرك مؤلفو serde مدى شيوع هذا الوضع وأضافوا صياغة remote مخصصة تحل المشكلة بدلًا منا.

في المثال الأول الذي ناقشناه سابقًا، لم يكن النوع Multiplicator ينفذ أنواع serde. وتقدم Serde آلية مخصصة لتفويض تسلسل (serialization) مثل هذه الأنواع، تعفينا من تنفيذ 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 ومفيدة لأكثر من تنفيذ سمات serde لأنواع من حزم أخرى، لكن ذلك يتجاوز نطاق هذا المقال. ما أريد الإشارة إليه هو أنه قبل اللجوء إلى نمط المحوّل لتجاوز orphan rule، من العادات الجيدة التحقق مما إذا كانت الحزمة التي تعرّف السمة تقدم صياغة خاصة تساعد بطريقة أكثر اتساقًا.

عام أم خاص؟

هناك جانب آخر لم أتناوله بعد، وكان موضوع جدل حول أنماط newtype. هل ينبغي أن يكون الحقل الوحيد للنوع عامًا أم خاصًا؟

وعلى عكس نمط newtype الخالص، لا يمثل إخفاء نوع التنفيذ الداخلي المشكلة التي نحاول حلها هنا. ولذلك، لا يوجد غالبًا سبب حقيقي لجعل الحقل خاصًا. لكن يبرز سؤال آخر: هل .0 واجهة برمجية جيدة للتمرير؟ شخصيًا لا تعجبني، وعند استخدام بنى tuple ذات حقل واحد لمحوّلاتي، أبقي الحقل عادةً خاصًا وأتيحه عبر السمة Deref أو دالة مخصصة.

ومن ناحية أخرى، إذا كنا سنضيف دالة إضافية على أي حال، فلعل الأفضل تحويل الحقل الوحيد إلى حقل مسمى بدلًا من استخدام tuple struct. يمكن إعادة صياغة ApplicatorAdapter إلى:

struct ApplicatorAdapter {
  pub inner: Multiplicator,
}

وما لم تكن هناك أسباب أخرى لإخفاء النوع الكامن، فإنني أعتبر هذا النهج متعارفًا عليه. وغالبًا ما يكون ذلك مسألة ذوق، وكذلك الظروف المحددة التي يُستخدم فيها النوع. لذا فرأيي هو: بالنسبة للمحوّل نفسه، فإن الظهور (visibility) ليس أمرًا يستحق القلق.

الخلاصة

في هذا المقال، فحصنا استخدامًا آخر للنمط الشبيه بـ newtype-like: المحوّل. وهو مفيد بشكل خاص في Rust - أكثر من اللغات الأخرى - لأن السمات والأنواع متعامدة، ولأجل Orphan Rule الناتجة عن ذلك.

والدرس الرئيسي هو أن المحوّل حل شامل. فلدى Serde الصياغة remote، وتوفر بعض الحزم أعلام ميزات (feature flags) لتنفيذات سمات عابرة للحزم، لكن عندما لا يتوفر شيء من هذا القبيل - وهو ما يحدث كثيرًا - فإن المحوّل أداة ممتازة. وقد رأينا ذلك مع axum وeyre: حزمتان شائعتان لا تعرف إحداهما الأخرى ولا توفران جسرًا مدمجًا.

ونظرنا أيضًا في كيفية جعل المحوّلات مريحة. فقد يبدو نوع المحوّل العاري غريبًا بمفرده، لكن مع extension traits وتنفيذات From وتصميم واجهة مدروس، يصبح شبه غير مرئي عند موضع الاستدعاء. ويتدرج النمط بسلاسة من زوج سمة-نوع واحد إلى عدة محوّلات متخصصة، كما أظهرت متغيرات رموز أخطاء HTTP.

وفي المقال التالي، سنفحص extension traits عن قرب أكبر - وهو نمط استخدمناه هنا بالفعل لجعل المحوّلات أكثر راحة، لكنه، كأسلوب قوي في Rust، يستحق أن يُسلَّط عليه الضوء بمفرده.