Compiler Explorer

Source code

const std = @import("std");

pub fn Implementation() type {
    const Impl = @OpaqueType();

return struct {
        const Self = @This();

impl: ?*Impl,

pub fn none() Self {
            return Self{ .impl = null };
        }

pub fn init(ptr: var) Self {
            const T = @typeOf(ptr);
            if (@alignOf(T) == 0) @compileError("0-Bit implementations can't be casted (and casting is unnecessary anyway, use .none)");
            return Self{ .impl = @ptrCast(*Impl, ptr) };
        }

pub fn cast(self: *const Self, comptime T: type) *T {
            if (@alignOf(T) == 0) @compileError("0-Bit implementations can't be casted (and casting is unnecessary anyway)");
            const aligned = @alignCast(@alignOf(T), self.impl);
            return @ptrCast(*T, aligned);
        }
    };
}

pub const Comparison = enum {
    Less,
    Equal,
    Greater,
};

pub const Comparable = struct {
    pub const Impl = Implementation();

pub fn compare(self: *Self, other: *Self) Comparison {
        return self._compare(self, other);
    }

pub fn equal(self: *Self, other: *Self) bool {
        return self.compare(other) == Comparison.Equal;
    }

pub fn less(self: *Self, other: *Self) bool {
        return self.compare(other) == Comparison.Less;
    }

pub fn greater(self: *Self, other: *Self) bool {
        return self.compare(other) == Comparison.Greater;
    }

const Self = @This();

impl: Impl,
    _compare: fn (self: *Self, other: *Self) Comparison,
};

pub const String = struct {
    const Self = @This();
    const Value = []const u8;

value: Value,

pub fn comparable(self: *Self) Comparable {
        return Comparable{
            .impl = Comparable.Impl.init(self),
            ._compare = compare,
        };
    }

fn compare(self: *const Comparable, other: *const Comparable) Comparison {
        const a = self.impl.cast(Self).value;
        const b = other.impl.cast(Self).value;
        const len = if (a.len < b.len) a.len else b.len;
        var i: usize = 0;
        while (i < len and a[i] == b[i]) : (i += 1) {}
        if (i == len) {
            if (a.len < b.len) {
                return Comparison.Less;
            } else if (a.len > b.len) {
                return Comparison.Greater;
            }
        } else {
            if (a[i] < b[i]) {
                return Comparison.Less;
            } else if (a[i] > b[i]) {
                return Comparison.Greater;
            }
        }
        return Comparison.Equal;
    }
};

pub fn main() void {
    var s1 = (String{ .value = "hello" }).comparable();
    var s2 = (String{ .value = "hello" }).comparable();
    var s3 = (String{ .value = "z" }).comparable();
    std.debug.assert(s1.equal(&s2));
    std.debug.assert(s1.less(&s3));
    std.debug.assert(s3.greater(&s2));
}