Decorator Design Pattern

public interface HttpClient {
    Response send(Request request);
}

public class RealHttpClient implements HttpClient {
    public Response send(Request r) { /* opens the socket */ }
}

public class RetryingClient implements HttpClient {
    private final HttpClient inner;      // the decorated object
    private final int attempts;

    public RetryingClient(HttpClient inner, int attempts) {
        this.inner = inner;
        this.attempts = attempts;
    }

    @Override public Response send(Request r) {
        RuntimeException last = null;
        for (int i = 0; i < attempts; i++) {
            try {
                return inner.send(r);        // delegate
            } catch (TransientException e) {
                last = e;
                sleep(backoff(i));
            }
        }
        throw last;
    }
}

public class LoggingClient implements HttpClient {
    private final HttpClient inner;
    public LoggingClient(HttpClient inner) { this.inner = inner; }

    @Override public Response send(Request r) {
        log.info("→ {} {}", r.method(), r.url());
        Response resp = inner.send(r);
        log.info("← {} in {}ms", resp.status(), resp.elapsedMillis());
        return resp;
    }
}

// Compose at the wiring site, in whatever order the behaviour requires:
HttpClient client =
    new LoggingClient(
        new RetryingClient(
            new RealHttpClient(), 3));

// Logging sees ONE line per logical call; retries happen inside it, unseen.
// Swap the two and you get a log line per attempt instead.

from typing import Protocol


class HttpClient(Protocol):
    def send(self, request: Request) -> Response: ...


class RealHttpClient:
    def send(self, request: Request) -> Response:
        ...  # opens the socket


class RetryingClient:
    def __init__(self, inner: HttpClient, attempts: int = 3) -> None:
        self._inner = inner
        self._attempts = attempts

    def send(self, request: Request) -> Response:
        for i in range(self._attempts):
            try:
                return self._inner.send(request)
            except TransientError:
                if i == self._attempts - 1:
                    raise
                time.sleep(backoff(i))


# Python's decorator SYNTAX (@retry) is a different thing that happens to share
# the name: it wraps a FUNCTION at definition time. The GoF pattern wraps an
# OBJECT at runtime, so you can stack layers differently per instance — one
# client with retries for a flaky vendor, another without.

client = LoggingClient(RetryingClient(RealHttpClient(), attempts=3))

# For a wide interface, __getattr__ forwards everything you didn't override,
# so a decorator only spells out the methods it actually changes:
#
#     def __getattr__(self, name):
#         return getattr(self._inner, name)

#include <memory>

struct HttpClient {
    virtual ~HttpClient() = default;
    virtual Response send(const Request&) = 0;
};

class RealHttpClient : public HttpClient {
public:
    Response send(const Request& r) override { /* opens the socket */ }
};

class RetryingClient : public HttpClient {
public:
    // unique_ptr: the decorator OWNS its inner client, and the whole stack is
    // destroyed correctly from the outside in.
    RetryingClient(std::unique_ptr<HttpClient> inner, int attempts)
        : inner_(std::move(inner)), attempts_(attempts) {}

    Response send(const Request& r) override {
        for (int i = 0; i < attempts_; ++i) {
            try {
                return inner_->send(r);
            } catch (const TransientError&) {
                if (i == attempts_ - 1) throw;
                std::this_thread::sleep_for(backoff(i));
            }
        }
        throw std::logic_error("unreachable");
    }

private:
    std::unique_ptr<HttpClient> inner_;
    int attempts_;
};

// auto client = std::make_unique<LoggingClient>(
//     std::make_unique<RetryingClient>(
//         std::make_unique<RealHttpClient>(), 3));

public interface IHttpClient
{
    Task<Response> SendAsync(Request request, CancellationToken ct = default);
}

public sealed class RetryingClient(IHttpClient inner, int attempts = 3) : IHttpClient
{
    public async Task<Response> SendAsync(Request request, CancellationToken ct = default)
    {
        for (var i = 0; i < attempts; i++)
        {
            try { return await inner.SendAsync(request, ct); }
            catch (TransientException) when (i < attempts - 1)
            {
                await Task.Delay(Backoff(i), ct);
            }
        }
        throw new UnreachableException();
    }
}

public sealed class LoggingClient(IHttpClient inner, ILogger<LoggingClient> log) : IHttpClient
{
    public async Task<Response> SendAsync(Request request, CancellationToken ct = default)
    {
        log.LogInformation("→ {Method} {Url}", request.Method, request.Url);
        var response = await inner.SendAsync(request, ct);
        log.LogInformation("← {Status}", response.Status);
        return response;
    }
}

// .NET ships an entire decorator pipeline for exactly this:
//
//     services.AddHttpClient<IApiClient, ApiClient>()
//             .AddHttpMessageHandler<LoggingHandler>()
//             .AddHttpMessageHandler<RetryHandler>();
//
// DelegatingHandler IS the Decorator pattern, named after what it does.

// A decorator only has to satisfy the same shape, so a plain function that
// returns a wrapped object is the lightest form.

const realClient = {
  async send(request) { /* fetch */ },
}

const withRetry = (inner, attempts = 3) => ({
  async send(request) {
    for (let i = 0; i < attempts; i++) {
      try {
        return await inner.send(request)
      } catch (err) {
        if (!err.transient || i === attempts - 1) throw err
        await sleep(backoff(i))
      }
    }
  },
})

const withLogging = inner => ({
  async send(request) {
    console.info('→', request.method, request.url)
    const response = await inner.send(request)
    console.info('←', response.status)
    return response
  },
})

// Composition reads inside-out, so a reduce makes the order explicit:
const compose = (...wrappers) => base => wrappers.reduceRight((acc, w) => w(acc), base)

const client = compose(withLogging, c => withRetry(c, 3))(realClient)

// For a wide interface, a Proxy forwards everything you don't override:
//   new Proxy(inner, { get: (t, k) => overrides[k] ?? Reflect.get(t, k) })

package httpx

// Go's small interfaces make decorators trivial, and the standard library is
// built out of them — this is exactly how http middleware works.

type Client interface {
	Send(*Request) (*Response, error)
}

type retrying struct {
	inner    Client
	attempts int
}

func WithRetry(inner Client, attempts int) Client {
	return retrying{inner: inner, attempts: attempts}
}

func (r retrying) Send(req *Request) (*Response, error) {
	var err error
	for i := 0; i < r.attempts; i++ {
		var resp *Response
		resp, err = r.inner.Send(req)
		if err == nil || !isTransient(err) {
			return resp, err
		}
		time.Sleep(backoff(i))
	}
	return nil, err
}

type logging struct{ inner Client }

func WithLogging(inner Client) Client { return logging{inner} }

func (l logging) Send(req *Request) (*Response, error) {
	log.Printf("→ %s %s", req.Method, req.URL)
	resp, err := l.inner.Send(req)
	log.Printf("← %v", err)
	return resp, err
}

// client := WithLogging(WithRetry(Real{}, 3))
//
// The constructors return the INTERFACE, not the struct, which is what lets
// them nest in any order without the caller knowing the concrete types.

interface HttpClient {
  send(request: Request): Promise<Response>
}

class RetryingClient implements HttpClient {
  constructor(
    private readonly inner: HttpClient,
    private readonly attempts = 3,
  ) {}

  async send(request: Request): Promise<Response> {
    for (let i = 0; i < this.attempts; i++) {
      try {
        return await this.inner.send(request)
      } catch (err) {
        if (!isTransient(err) || i === this.attempts - 1) throw err
        await sleep(backoff(i))
      }
    }
    throw new Error('unreachable')
  }
}

class LoggingClient implements HttpClient {
  constructor(private readonly inner: HttpClient) {}

  async send(request: Request): Promise<Response> {
    console.info('→', request.method, request.url)
    const response = await this.inner.send(request)
    console.info('←', response.status)
    return response
  }
}

// The type system does real work here: because every wrapper is declared as
// `implements HttpClient` and takes an `HttpClient`, ANY nesting order
// type-checks — and forgetting to delegate a method is a compile error.
const client: HttpClient = new LoggingClient(new RetryingClient(new RealHttpClient(), 3))

// Not to be confused with TypeScript's `@decorator` syntax, which is a
// different feature that annotates classes and members at declaration time.