tiny.preserves.Atom

1/// A copy of one atom, tagged by its kind. Code that takes one atom out of a value holds it in this2/// type, as `Value.asAtom` returns it. Booleans and doubles are stored directly. Strings, byte3/// strings and symbols are stored as bytes with an ownership tag, and integers as an integer with4/// one. `Value.asAtom` builds one that borrows from a value.5pub const Atom = union(AtomClass) {6    /// The boolean.7    boolean: bool,8    /// The double.9    double: f64,10    /// The integer, with whether its holder owns its digits.11    signed_integer: CowSignedInteger,12    /// The string's bytes, with whether its holder owns them.13    string: CowBytes,14    /// The byte string's bytes, with whether its holder owns them.15    byte_string: CowBytes,16    /// The symbol's name bytes, with whether its holder owns them.17    symbol: CowBytes,1819    /// Returns the atom's kind. Code that switches on an atom's kind calls it.20    pub fn class(self: Atom) AtomClass {21        return @as(AtomClass, self);22    }2324    /// Makes a boolean atom from `v`. `Value.asAtom` calls it for a boolean atom.25    pub fn fromBool(v: bool) Atom {26        return .{ .boolean = v };27    }2829    /// Makes a double atom from `v`. `Value.asAtom` calls it for a double atom.30    pub fn fromDouble(v: f64) Atom {31        return .{ .double = v };32    }3334    /// Makes an integer atom that borrows `v`'s digits. `Value.asAtom` calls it for an integer atom35    /// over the value's own digits.36    pub fn fromSignedIntegerBorrowed(v: SignedInteger) Atom {37        return .{ .signed_integer = CowSignedInteger.borrow(v) };38    }3940    /// Makes an integer atom that owns `v`'s digits, so its `deinit` frees them. Code that hands an41    /// integer's digits to the atom calls it.42    pub fn fromSignedIntegerOwned(v: SignedInteger) Atom {43        return .{ .signed_integer = CowSignedInteger.own(v) };44    }4546    /// Makes a string atom that borrows `bytes`. `Value.asAtom` calls it for a string atom over the47    /// value's own bytes.48    pub fn fromStringBorrowed(bytes: []const u8) Atom {49        return .{ .string = CowBytes.borrow(bytes) };50    }5152    /// Makes a string atom that owns `bytes`, so its `deinit` frees them. Code that hands a53    /// string's bytes to the atom calls it.54    pub fn fromStringOwned(bytes: []const u8) Atom {55        return .{ .string = CowBytes.own(bytes) };56    }5758    /// Makes a byte-string atom that borrows `bytes`. `Value.asAtom` calls it for a byte-string59    /// atom over the value's own bytes.60    pub fn fromByteStringBorrowed(bytes: []const u8) Atom {61        return .{ .byte_string = CowBytes.borrow(bytes) };62    }6364    /// Makes a byte-string atom that owns `bytes`, so its `deinit` frees them. Code that hands a65    /// byte string's bytes to the atom calls it.66    pub fn fromByteStringOwned(bytes: []const u8) Atom {67        return .{ .byte_string = CowBytes.own(bytes) };68    }6970    /// Makes a symbol atom that borrows `bytes`. `Value.asAtom` calls it for a symbol atom over the71    /// value's own bytes.72    pub fn fromSymbolBorrowed(bytes: []const u8) Atom {73        return .{ .symbol = CowBytes.borrow(bytes) };74    }7576    /// Makes a symbol atom that owns `bytes`, so its `deinit` frees them. Code that hands a77    /// symbol's bytes to the atom calls it.78    pub fn fromSymbolOwned(bytes: []const u8) Atom {79        return .{ .symbol = CowBytes.own(bytes) };80    }8182    /// Frees the atom's bytes or digits with `allocator` when it owns them. Code that holds the83    /// atom calls it when it is done with it. Booleans and doubles need nothing. The atom is84    /// undefined afterward.85    pub fn deinit(self: *Atom, allocator: Allocator) void {86        switch (self.*) {87            .boolean, .double => {},88            .signed_integer => |*c| c.deinit(allocator),89            .string => |*c| c.deinit(allocator),90            .byte_string => |*c| c.deinit(allocator),91            .symbol => |*c| c.deinit(allocator),92        }93        self.* = undefined;94    }9596    /// Returns a copy of the atom that owns its bytes or digits, copying borrowed ones into storage97    /// from `allocator`. Code that keeps an atom calls it so the atom outlives the value it came98    /// from. Parts that are already owned come back with no copy, so the result shares them with99    /// the original and only one of the two may be freed.100    pub fn intoOwned(self: Atom, allocator: Allocator) !Atom {101        return switch (self) {102            .boolean, .double => self,103            .signed_integer => |c| .{ .signed_integer = try c.intoOwned(allocator) },104            .string => |c| .{ .string = try c.intoOwned(allocator) },105            .byte_string => |c| .{ .byte_string = try c.intoOwned(allocator) },106            .symbol => |c| .{ .symbol = try c.intoOwned(allocator) },107        };108    }109110    /// Returns whether two atoms have the same kind and the same contents, whatever their ownership111    /// tags. Code that compares atoms from different owners calls it, so ownership plays no part.112    /// Doubles are equal when their bit patterns are equal, so a `NaN` equals a `NaN` with the same113    /// bits and `0.0` differs from `-0.0`. Integers compare with `SignedInteger.eql`.114    pub fn eql(a: Atom, b: Atom) bool {115        if (a.class() != b.class()) return false;116        return switch (a) {117            .boolean => |v| v == b.boolean,118            .double => |v| @as(u64, @bitCast(v)) == @as(u64, @bitCast(b.double)),119            .signed_integer => |c| c.value.eql(b.signed_integer.value),120            .string => |c| std.mem.eql(u8, c.bytes, b.string.bytes),121            .byte_string => |c| std.mem.eql(u8, c.bytes, b.byte_string.bytes),122            .symbol => |c| std.mem.eql(u8, c.bytes, b.symbol.bytes),123        };124    }125};

1pub const Atom = atom.Atom;