Creational Patterns: Factory, Builder, Singleton

package main

import (
	"errors"
	"fmt"
	"strings"
)

// ---- Factory: callers ask for "a sender for this channel" and never name the concrete type.

type Sender interface {
	Send(to, msg string) string
}

type SMS struct{}

func (SMS) Send(to, msg string) string { return "sms    -> " + to + ": " + msg }

type Email struct{}

func (Email) Send(to, msg string) string { return "email  -> " + to + ": " + msg }

// NewSender is the one place that knows which type serves which channel.
func NewSender(channel string) (Sender, error) {
	switch channel {
	case "sms":
		return SMS{}, nil
	case "email":
		return Email{}, nil
	}
	return nil, fmt.Errorf("unknown channel %q", channel)
}

// ---- Builder: a parcel has a few required fields and several optional ones.

type Parcel struct {
	ID, From, To string
	Kg, COD      int
	Fragile      bool
}

type ParcelBuilder struct{ p Parcel }

func NewParcel(id, from, to string) *ParcelBuilder {
	return &ParcelBuilder{Parcel{ID: id, From: from, To: to, Kg: 1}}
}
func (b *ParcelBuilder) Weight(kg int) *ParcelBuilder         { b.p.Kg = kg; return b }
func (b *ParcelBuilder) CashOnDelivery(tk int) *ParcelBuilder { b.p.COD = tk; return b }
func (b *ParcelBuilder) Fragile() *ParcelBuilder              { b.p.Fragile = true; return b }

// Build checks the whole object once, so a half-valid parcel can never exist.
func (b *ParcelBuilder) Build() (Parcel, error) {
	if b.p.Kg < 1 || b.p.Kg > 30 {
		return Parcel{}, errors.New("weight must be 1-30 kg")
	}
	if b.p.From == b.p.To {
		return Parcel{}, errors.New("from and to are the same city")
	}
	return b.p, nil
}

func (p Parcel) String() string {
	parts := []string{fmt.Sprintf("%s -> %s, %d kg", p.From, p.To, p.Kg)}
	if p.COD > 0 {
		parts = append(parts, fmt.Sprintf("cod %d tk", p.COD))
	}
	if p.Fragile {
		parts = append(parts, "fragile")
	}
	return strings.Join(parts, ", ")
}

func main() {
	for _, ch := range []string{"sms", "email", "push"} {
		s, err := NewSender(ch)
		if err != nil {
			fmt.Printf("%-6s : %v\n", ch, err)
			continue
		}
		to := map[string]string{"sms": "01711000000", "email": "rahim@example.com"}[ch]
		fmt.Println(s.Send(to, "Your OTP is 4821"))
	}

	builders := []*ParcelBuilder{
		NewParcel("P-1", "Dhaka", "Sylhet").Weight(2).CashOnDelivery(1500).Fragile(),
		NewParcel("P-2", "Dhaka", "Khulna"),
		NewParcel("P-3", "Dhaka", "Rajshahi").Weight(45),
		NewParcel("P-4", "Dhaka", "Dhaka").Weight(3),
	}
	for _, b := range builders {
		p, err := b.Build()
		if err != nil {
			fmt.Printf("parcel %s: refused: %v\n", b.p.ID, err)
			continue
		}
		fmt.Printf("parcel %s: %s\n", p.ID, p)
	}
}

from __future__ import annotations

from dataclasses import dataclass, replace
from typing import Protocol


# ---- Factory: callers ask for "a sender for this channel" and never name the concrete class.

class Sender(Protocol):
    def send(self, to: str, msg: str) -> str: ...


class SMS:
    def send(self, to: str, msg: str) -> str:
        return f"sms    -> {to}: {msg}"


class Email:
    def send(self, to: str, msg: str) -> str:
        return f"email  -> {to}: {msg}"


def new_sender(channel: str) -> Sender:
    """The one place that knows which class serves which channel."""
    senders: dict[str, type[Sender]] = {"sms": SMS, "email": Email}
    if channel not in senders:
        raise ValueError(f'unknown channel "{channel}"')
    return senders[channel]()


# ---- Builder: a parcel has a few required fields and several optional ones.

@dataclass(frozen=True)
class Parcel:
    id: str
    frm: str
    to: str
    kg: int = 1
    cod: int = 0
    fragile: bool = False

    def __str__(self) -> str:
        parts = [f"{self.frm} -> {self.to}, {self.kg} kg"]
        if self.cod:
            parts.append(f"cod {self.cod} tk")
        if self.fragile:
            parts.append("fragile")
        return ", ".join(parts)


class ParcelBuilder:
    def __init__(self, id: str, frm: str, to: str):
        self.p = Parcel(id, frm, to)

    def weight(self, kg: int) -> ParcelBuilder:
        self.p = replace(self.p, kg=kg)
        return self

    def cash_on_delivery(self, tk: int) -> ParcelBuilder:
        self.p = replace(self.p, cod=tk)
        return self

    def fragile(self) -> ParcelBuilder:
        self.p = replace(self.p, fragile=True)
        return self

    def build(self) -> Parcel:
        """Checks the whole object once, so a half-valid parcel can never exist."""
        if not 1 <= self.p.kg <= 30:
            raise ValueError("weight must be 1-30 kg")
        if self.p.frm == self.p.to:
            raise ValueError("from and to are the same city")
        return self.p


addresses = {"sms": "01711000000", "email": "rahim@example.com"}
for ch in ("sms", "email", "push"):
    try:
        print(new_sender(ch).send(addresses.get(ch, ""), "Your OTP is 4821"))
    except ValueError as e:
        print(f"{ch:<6} : {e}")

builders = [
    ParcelBuilder("P-1", "Dhaka", "Sylhet").weight(2).cash_on_delivery(1500).fragile(),
    ParcelBuilder("P-2", "Dhaka", "Khulna"),
    ParcelBuilder("P-3", "Dhaka", "Rajshahi").weight(45),
    ParcelBuilder("P-4", "Dhaka", "Dhaka").weight(3),
]
for b in builders:
    try:
        p = b.build()
        print(f"parcel {p.id}: {p}")
    except ValueError as e:
        print(f"parcel {b.p.id}: refused: {e}")

// ---- Factory: callers ask for "a sender for this channel" and never name the concrete class.

interface Sender {
  send(to: string, msg: string): string;
}

class SMS implements Sender {
  send(to: string, msg: string): string {
    return `sms    -> ${to}: ${msg}`;
  }
}

class Email implements Sender {
  send(to: string, msg: string): string {
    return `email  -> ${to}: ${msg}`;
  }
}

// The one place that knows which class serves which channel.
function newSender(channel: string): Sender {
  const senders: Record<string, () => Sender> = { sms: () => new SMS(), email: () => new Email() };
  const make = senders[channel];
  if (!make) throw new Error(`unknown channel "${channel}"`);
  return make();
}

// ---- Builder: a parcel has a few required fields and several optional ones.

interface Parcel {
  readonly id: string;
  readonly from: string;
  readonly to: string;
  readonly kg: number;
  readonly cod: number;
  readonly fragile: boolean;
}

class ParcelBuilder {
  readonly p: { -readonly [K in keyof Parcel]: Parcel[K] };
  constructor(id: string, from: string, to: string) {
    this.p = { id, from, to, kg: 1, cod: 0, fragile: false };
  }
  weight(kg: number): this {
    this.p.kg = kg;
    return this;
  }
  cashOnDelivery(tk: number): this {
    this.p.cod = tk;
    return this;
  }
  fragile(): this {
    this.p.fragile = true;
    return this;
  }
  // Checks the whole object once, so a half-valid parcel can never exist.
  build(): Parcel {
    if (this.p.kg < 1 || this.p.kg > 30) throw new Error("weight must be 1-30 kg");
    if (this.p.from === this.p.to) throw new Error("from and to are the same city");
    return Object.freeze({ ...this.p });
  }
}

function describe(p: Parcel): string {
  const parts = [`${p.from} -> ${p.to}, ${p.kg} kg`];
  if (p.cod > 0) parts.push(`cod ${p.cod} tk`);
  if (p.fragile) parts.push("fragile");
  return parts.join(", ");
}

const addresses: Record<string, string> = { sms: "01711000000", email: "rahim@example.com" };
for (const ch of ["sms", "email", "push"]) {
  try {
    console.log(newSender(ch).send(addresses[ch] ?? "", "Your OTP is 4821"));
  } catch (e) {
    console.log(`${ch.padEnd(6)} : ${(e as Error).message}`);
  }
}

const builders = [
  new ParcelBuilder("P-1", "Dhaka", "Sylhet").weight(2).cashOnDelivery(1500).fragile(),
  new ParcelBuilder("P-2", "Dhaka", "Khulna"),
  new ParcelBuilder("P-3", "Dhaka", "Rajshahi").weight(45),
  new ParcelBuilder("P-4", "Dhaka", "Dhaka").weight(3),
];
for (const b of builders) {
  try {
    const p = b.build();
    console.log(`parcel ${p.id}: ${describe(p)}`);
  } catch (e) {
    console.log(`parcel ${b.p.id}: refused: ${(e as Error).message}`);
  }
}

use std::fmt;

// ---- Factory: callers ask for "a sender for this channel" and never name the concrete type.

trait Sender { fn send(&self, to: &str, msg: &str) -> String; }

struct Sms;
impl Sender for Sms { fn send(&self, to: &str, msg: &str) -> String { format!("sms    -> {to}: {msg}") } }

struct Email;
impl Sender for Email { fn send(&self, to: &str, msg: &str) -> String { format!("email  -> {to}: {msg}") } }

// The one place that knows which type serves which channel.
fn new_sender(channel: &str) -> Result<Box<dyn Sender>, String> {
    match channel {
        "sms" => Ok(Box::new(Sms)),
        "email" => Ok(Box::new(Email)),
        _ => Err(format!("unknown channel \"{channel}\"")),
    }
}

// ---- Builder: a parcel has a few required fields and several optional ones.

#[derive(Clone)]
struct Parcel { id: String, from: String, to: String, kg: u32, cod: u32, fragile: bool }

impl fmt::Display for Parcel {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} -> {}, {} kg", self.from, self.to, self.kg)?;
        if self.cod > 0 { write!(f, ", cod {} tk", self.cod)?; }
        if self.fragile { write!(f, ", fragile")?; }
        Ok(())
    }
}

// Rust builders usually take `self` by value, so each step moves the builder along.
struct ParcelBuilder { p: Parcel }

impl ParcelBuilder {
    fn new(id: &str, from: &str, to: &str) -> Self {
        ParcelBuilder { p: Parcel { id: id.into(), from: from.into(), to: to.into(), kg: 1, cod: 0, fragile: false } }
    }
    fn weight(mut self, kg: u32) -> Self { self.p.kg = kg; self }
    fn cash_on_delivery(mut self, tk: u32) -> Self { self.p.cod = tk; self }
    fn fragile(mut self) -> Self { self.p.fragile = true; self }

    // Checks the whole object once, so a half-valid parcel can never exist.
    fn build(&self) -> Result<Parcel, String> {
        if !(1..=30).contains(&self.p.kg) { return Err("weight must be 1-30 kg".into()); }
        if self.p.from == self.p.to { return Err("from and to are the same city".into()); }
        Ok(self.p.clone())
    }
}

fn main() {
    for ch in ["sms", "email", "push"] {
        let to = match ch { "sms" => "01711000000", "email" => "rahim@example.com", _ => "" };
        match new_sender(ch) {
            Ok(s) => println!("{}", s.send(to, "Your OTP is 4821")),
            Err(e) => println!("{ch:<6} : {e}"),
        }
    }

    let builders = [
        ParcelBuilder::new("P-1", "Dhaka", "Sylhet").weight(2).cash_on_delivery(1500).fragile(),
        ParcelBuilder::new("P-2", "Dhaka", "Khulna"),
        ParcelBuilder::new("P-3", "Dhaka", "Rajshahi").weight(45),
        ParcelBuilder::new("P-4", "Dhaka", "Dhaka").weight(3),
    ];
    for b in &builders {
        match b.build() {
            Ok(p) => println!("parcel {}: {p}", p.id),
            Err(e) => println!("parcel {}: refused: {e}", b.p.id),
        }
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;

public class Main {
    // ---- Factory: callers ask for "a sender for this channel" and never name the concrete class.

    interface Sender { String send(String to, String msg); }

    static final class Sms implements Sender {
        public String send(String to, String msg) { return "sms    -> " + to + ": " + msg; }
    }

    static final class Email implements Sender {
        public String send(String to, String msg) { return "email  -> " + to + ": " + msg; }
    }

    // The one place that knows which class serves which channel.
    static Sender newSender(String channel) {
        Map<String, Supplier<Sender>> senders = Map.of("sms", Sms::new, "email", Email::new);
        Supplier<Sender> make = senders.get(channel);
        if (make == null) throw new IllegalArgumentException("unknown channel \"" + channel + "\"");
        return make.get();
    }

    // ---- Builder: a parcel has a few required fields and several optional ones.

    record Parcel(String id, String from, String to, int kg, int cod, boolean fragile) {
        @Override public String toString() {
            List<String> parts = new ArrayList<>(List.of(from + " -> " + to + ", " + kg + " kg"));
            if (cod > 0) parts.add("cod " + cod + " tk");
            if (fragile) parts.add("fragile");
            return String.join(", ", parts);
        }
    }

    static final class ParcelBuilder {
        final String id, from, to;
        private int kg = 1, cod = 0;
        private boolean fragile = false;

        ParcelBuilder(String id, String from, String to) { this.id = id; this.from = from; this.to = to; }
        ParcelBuilder weight(int kg) { this.kg = kg; return this; }
        ParcelBuilder cashOnDelivery(int tk) { this.cod = tk; return this; }
        ParcelBuilder fragile() { this.fragile = true; return this; }

        // Checks the whole object once, so a half-valid parcel can never exist.
        Parcel build() {
            if (kg < 1 || kg > 30) throw new IllegalArgumentException("weight must be 1-30 kg");
            if (from.equals(to)) throw new IllegalArgumentException("from and to are the same city");
            return new Parcel(id, from, to, kg, cod, fragile);
        }
    }

    public static void main(String[] args) {
        Map<String, String> addresses = Map.of("sms", "01711000000", "email", "rahim@example.com");
        for (String ch : List.of("sms", "email", "push")) {
            try {
                System.out.println(newSender(ch).send(addresses.getOrDefault(ch, ""), "Your OTP is 4821"));
            } catch (IllegalArgumentException e) {
                System.out.printf("%-6s : %s%n", ch, e.getMessage());
            }
        }

        List<ParcelBuilder> builders = List.of(
            new ParcelBuilder("P-1", "Dhaka", "Sylhet").weight(2).cashOnDelivery(1500).fragile(),
            new ParcelBuilder("P-2", "Dhaka", "Khulna"),
            new ParcelBuilder("P-3", "Dhaka", "Rajshahi").weight(45),
            new ParcelBuilder("P-4", "Dhaka", "Dhaka").weight(3));
        for (ParcelBuilder b : builders) {
            try {
                Parcel p = b.build();
                System.out.printf("parcel %s: %s%n", p.id(), p);
            } catch (IllegalArgumentException e) {
                System.out.printf("parcel %s: refused: %s%n", b.id, e.getMessage());
            }
        }
    }
}

#include <cstdio>
#include <functional>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

// ---- Factory: callers ask for "a sender for this channel" and never name the concrete class.

class Sender {
public:
    virtual ~Sender() = default;
    virtual std::string send(const std::string& to, const std::string& msg) const = 0;
};

class Sms : public Sender {
public:
    std::string send(const std::string& to, const std::string& msg) const override {
        return "sms    -> " + to + ": " + msg;
    }
};

class Email : public Sender {
public:
    std::string send(const std::string& to, const std::string& msg) const override {
        return "email  -> " + to + ": " + msg;
    }
};

// The one place that knows which class serves which channel.
std::unique_ptr<Sender> newSender(const std::string& channel) {
    static const std::map<std::string, std::function<std::unique_ptr<Sender>()>> senders = {
        {"sms", [] { return std::make_unique<Sms>(); }},
        {"email", [] { return std::make_unique<Email>(); }},
    };
    auto it = senders.find(channel);
    if (it == senders.end()) throw std::invalid_argument("unknown channel \"" + channel + "\"");
    return it->second();
}

// ---- Builder: a parcel has a few required fields and several optional ones.

struct Parcel {
    std::string id, from, to;
    int kg = 1, cod = 0;
    bool fragile = false;
    std::string str() const {
        std::string s = from + " -> " + to + ", " + std::to_string(kg) + " kg";
        if (cod > 0) s += ", cod " + std::to_string(cod) + " tk";
        if (fragile) s += ", fragile";
        return s;
    }
};

class ParcelBuilder {
public:
    ParcelBuilder(std::string id, std::string from, std::string to) : p_{std::move(id), std::move(from), std::move(to)} {}
    ParcelBuilder& weight(int kg) { p_.kg = kg; return *this; }
    ParcelBuilder& cashOnDelivery(int tk) { p_.cod = tk; return *this; }
    ParcelBuilder& fragile() { p_.fragile = true; return *this; }

    // Checks the whole object once, so a half-valid parcel can never exist.
    Parcel build() const {
        if (p_.kg < 1 || p_.kg > 30) throw std::invalid_argument("weight must be 1-30 kg");
        if (p_.from == p_.to) throw std::invalid_argument("from and to are the same city");
        return p_;
    }
    const std::string& id() const { return p_.id; }

private:
    Parcel p_;
};

int main() {
    std::map<std::string, std::string> addresses{{"sms", "01711000000"}, {"email", "rahim@example.com"}};
    for (std::string ch : {"sms", "email", "push"}) {
        try {
            std::printf("%s\n", newSender(ch)->send(addresses[ch], "Your OTP is 4821").c_str());
        } catch (const std::invalid_argument& e) {
            std::printf("%-6s : %s\n", ch.c_str(), e.what());
        }
    }

    std::vector<ParcelBuilder> builders{
        ParcelBuilder("P-1", "Dhaka", "Sylhet").weight(2).cashOnDelivery(1500).fragile(),
        ParcelBuilder("P-2", "Dhaka", "Khulna"),
        ParcelBuilder("P-3", "Dhaka", "Rajshahi").weight(45),
        ParcelBuilder("P-4", "Dhaka", "Dhaka").weight(3),
    };
    for (const auto& b : builders) {
        try {
            Parcel p = b.build();
            std::printf("parcel %s: %s\n", p.id.c_str(), p.str().c_str());
        } catch (const std::invalid_argument& e) {
            std::printf("parcel %s: refused: %s\n", b.id().c_str(), e.what());
        }
    }
}