#![allow(unused)]

trait WriterKind {
    type Written;
}

struct Writer<K: WriterKind> {
    m: std::marker::PhantomData<fn(&K::Written)>,
}

struct BasicWriter<T>(std::marker::PhantomData<T>);

impl<T> WriterKind for BasicWriter<T> {
    type Written = T;
}

impl<T> Writer<BasicWriter<T>> {
    fn write(&mut self, val: &T) {} // basic implementation (accepts only exactly &T)
}

struct RecordWriter;

impl WriterKind for RecordWriter {
    type Written = Record<'static>;
}

impl Writer<RecordWriter> {
    fn write(&mut self, val: &Record) {} // custom implementation (accepts any &Record<'?>)
}

struct Record<'a> {
    x: &'a i32,
}

// Don't want a lifetime parameter on `Logger`
struct Logger {
    rec_writer: Writer<RecordWriter>,
}

impl Logger {
    fn write_record(&mut self) {
        let x = 5;
        let rec = Record { x: &x };
        self.rec_writer.write(&rec);
    }
}

fn main() {}