#include <utility>
#include <cstddef>
#include <memory>
#include <iostream>
#include <tuple>

template<typename T, typename Deleter = std::default_delete<T> >
class UniquePtr {
public:
    UniquePtr() : data_(std::make_tuple(nullptr, Deleter())) {}

    const Deleter& get_deleter() const {
        return std::get<1>(data_);
    }
    Deleter& get_deleter() {
        return std::get<1>(data_);
    }

    void reset(T *ptr) {
        get_deleter()(std::get<0>(data_));
        std::get<0>(data_) = ptr;
    }

    explicit UniquePtr(T *ptr) : data_(ptr, Deleter()) {}

    UniquePtr(T *ptr, const Deleter &del) : data_(std::make_tuple(ptr, del)) {}

    UniquePtr(UniquePtr &&other) noexcept {
        data_ = other.data_;
        other.release();
    }

    UniquePtr &operator=(const UniquePtr &other) = delete;

    UniquePtr(const UniquePtr &other) = delete;

    UniquePtr &operator=(std::nullptr_t) noexcept {
        reset(nullptr);
        return *this;
    }

    T& operator*() const {
        return *std::get<0>(data_);
    }

    T *operator->() const noexcept {
        return std::get<0>(data_);
    }

    T *release() noexcept {
        auto ref = std::get<0>(data_);
        std::get<0>(data_) = nullptr;
        return ref;
    }

    UniquePtr &operator=(UniquePtr &&other) noexcept {
        data_ = other.data_;
        other.release();
        return *this;
    }

    void swap(UniquePtr &other) noexcept {
        std::swap(data_, other.data_);
    }

    T *get() const noexcept {
        return std::get<0>(data_);
    }

    explicit operator bool() const noexcept {
        return std::get<0>(data_) != nullptr;
    }

    ~UniquePtr() {
        get_deleter()(std::get<0>(data_));
    }

private:
    std::tuple<T*, Deleter> data_;
};