Spring SALE

Adapter em Rust

O Adapter é um padrão de projeto estrutural, que permite a colaboração de objetos incompatíveis.

O Adapter atua como um wrapper entre dois objetos. Ele captura chamadas para um objeto e as deixa reconhecíveis tanto em formato como interface para este segundo objeto.

Adapter in Rust

In this example, the trait SpecificTarget is incompatible with a call function which accepts trait Target only.

fn call(target: impl Target);

The adapter helps to pass the incompatible interface to the call function.

let target = TargetAdapter::new(specific_target);


use crate::{adaptee::SpecificTarget, Target};

/// Converts adaptee's specific interface to a compatible `Target` output.
pub struct TargetAdapter {
    adaptee: SpecificTarget,

impl TargetAdapter {
    pub fn new(adaptee: SpecificTarget) -> Self {
        Self { adaptee }

impl Target for TargetAdapter {
    fn request(&self) -> String {
        // Here's the "adaptation" of a specific output to a compatible output.


pub struct SpecificTarget;

impl SpecificTarget {
    pub fn specific_request(&self) -> String {
        ".tseuqer cificepS".into()


pub trait Target {
    fn request(&self) -> String;

pub struct OrdinaryTarget;

impl Target for OrdinaryTarget {
    fn request(&self) -> String {
        "Ordinary request.".into()


mod adaptee;
mod adapter;
mod target;

use adaptee::SpecificTarget;
use adapter::TargetAdapter;
use target::{OrdinaryTarget, Target};

/// Calls any object of a `Target` trait.
/// To understand the Adapter pattern better, imagine that this is
/// a client code, which can operate over a specific interface only
/// (`Target` trait only). It means that an incompatible interface cannot be
/// passed here without an adapter.
fn call(target: impl Target) {
    println!("'{}'", target.request());

fn main() {
    let target = OrdinaryTarget;

    print!("A compatible target can be directly called: ");

    let adaptee = SpecificTarget;

        "Adaptee is incompatible with client: '{}'",

    let adapter = TargetAdapter::new(adaptee);

    print!("But with adapter client can call its method: ");


A compatible target can be directly called: 'Ordinary request.'
Adaptee is incompatible with client: '.tseuqer cificepS'
But with adapter client can call its method: 'Specific request.'

Adapter em outras linguagens

Adapter em C# Adapter em C++ Adapter em Go Adapter em Java Adapter em PHP Adapter em Python Adapter em Ruby Adapter em Swift Adapter em TypeScript