Proposal: Way to force a struct/type to be distinct/unique

[suirad]

Background:

A strangeness that @DutchGhost and I found when developing zorrow was that in order to have comptime variables be instanced for a specific struct, we needed to introduce a var to force it to treat that type as unique. Otherwise those type seem to alias to another, causing comptime values to either not matter or not mutate for that type.

The following 3 examples will illustrate what is expected to "just work", the required way to accomplish it and the proposed change to accomplish it.

---

Expected:

const testing = @import("std").testing;

fn GiveTwice(comptime valt: type) type {
    comptime var times: usize = 2;
    return struct {
        val: valt,

        const Self = @This();

        pub fn init(_val: valt) Self {
            return Self{ .val = _val };
        }

        pub fn give(self: *Self) valt {
            comptime if (times == 0)
                @compileError("You can only 'give' 2 times");

            times -= 1;

            return self.val;
        }
    };
}

test "Test 1" {
    var a = GiveTwice(usize).init(1);
    _ = a.give();
    _ = a.give();
    _ = a.give(); // <-- Should Fail

    var b = GiveTwice(usize).init(1);
    _ = b.give();
    _ = b.give();
    _ = b.give(); // <-- Should Fail
}

Required:

const testing = @import("std").testing;

fn GiveTwice(comptime valt: type, comptime uniq: var) type {
    comptime var times: usize = 2;
    return struct {
        val: valt,

        const Self = @This();

        pub fn init(_val: valt) Self {
            return Self{ .val = _val };
        }

        pub fn give(self: *Self, comptime _uniq: var) valt {
            comptime if (times == 0)
                @compileError("You can only 'give' 2 times");

            times -= 1;

            return self.val;
        }
    };
}

test "Test 1" {
    var a = GiveTwice(usize, .{}).init(1);
    _ = a.give(.{});
    _ = a.give(.{});
    _ = a.give(.{}); // <-- Should Fail

    var b = GiveTwice(usize, .{}).init(1);
    _ = b.give(.{});
    _ = b.give(.{});
    _ = b.give(.{}); // <-- Should Fail
}

Proposed:

const testing = @import("std").testing;

fn GiveTwice(comptime valt: type) distinct type {
    comptime var times: usize = 2;
    return struct distinct {
        val: valt,

        const Self = @This();

        pub fn init(_val: valt) Self {
            return Self{ .val = _val };
        }

        pub fn give(self: *Self) valt {
            comptime if (times == 0)
                @compileError("You can only 'give' 2 times");

            times -= 1;

            return self.val;
        }
    };
}

test "Test 1" {
    var a = GiveTwice(usize).init(1);
    _ = a.give();
    _ = a.give();
    _ = a.give(); // <-- Should Fail

    var b = GiveTwice(usize).init(1);
    _ = b.give();
    _ = b.give();
    _ = b.give(); // <-- Should Fail
}

---

Summary:

The reason for the distinct keyword or something to that effect, is to solve the following problems:

• Without the uniq arg on the .give() , the comptime var times doesn't persist mutations
• Without the uniq arg on the GiveTwice(), any subsequent GiveTwice instance aliases to the first

[emekoi]

duplicate?: #1595

[ghost]

This relies on explicit ordering of comptime operations and closure, which is incredibly hexaflexagonical and possibly imposes tighter restrictions on comptime than we'd like. Also, if you're trying to implement a borrow checker, you'll need to handle more cases than this will let you.

As it stands, the proposed use case could be accomplished by accompanying each wrapped value with a GiveToken, and could be made much more convenient if comptime struct field semantics worked slightly differently. I'll open an issue for that, hang on.

[ghost]

The above linked issue proposes another solution that doesn't get into the weeds of comptime execution.