From 21d41a6b5b71f14cbd39903502d7597f90c3b5fb Mon Sep 17 00:00:00 2001
From: Jason Phan <jason@ket.so>
Date: Sat, 22 Jul 2023 14:31:01 -0500
Subject: [PATCH] ser, de: Simplify parameter names for (de)serialize

---
 src/de/deserialize.zig | 16 ++++++++--------
 src/ser/serialize.zig  | 22 +++++++++++-----------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/de/deserialize.zig b/src/de/deserialize.zig
index 03c4b143..8567995d 100644
--- a/src/de/deserialize.zig
+++ b/src/de/deserialize.zig
@@ -11,34 +11,34 @@ const Visitor = @import("interfaces/visitor.zig").Visitor;
 /// Deserializes data from a `getty.Deserializer` `d` into a value of type `T`.
 pub fn deserialize(
     /// An optional memory allocator.
-    allocator: ?std.mem.Allocator,
+    a: ?std.mem.Allocator,
     /// The type of the value to deserialize into.
     comptime T: type,
     /// A `getty.Deserializer` interface value.
-    deserializer: anytype,
-) @TypeOf(deserializer).Error!T {
-    const db = comptime find_db(T, @TypeOf(deserializer));
+    d: anytype,
+) @TypeOf(d).Error!T {
+    const db = comptime find_db(T, @TypeOf(d));
 
     if (comptime attributes.has_attributes(T, db)) {
         switch (@typeInfo(T)) {
             .Enum => {
                 var v = blocks.Enum.Visitor(T){};
-                return try blocks.Enum.deserialize(allocator, T, deserializer, v.visitor());
+                return try blocks.Enum.deserialize(a, T, d, v.visitor());
             },
             .Struct => {
                 var v = blocks.Struct.Visitor(T){};
-                return try blocks.Struct.deserialize(allocator, T, deserializer, v.visitor());
+                return try blocks.Struct.deserialize(a, T, d, v.visitor());
             },
             .Union => {
                 var v = blocks.Union.Visitor(T){};
-                return try blocks.Union.deserialize(allocator, T, deserializer, v.visitor());
+                return try blocks.Union.deserialize(a, T, d, v.visitor());
             },
             else => unreachable, // UNREACHABLE: has_attributes guarantees that T is an enum, struct or union.
         }
     }
 
     var v = db.Visitor(T){};
-    return try db.deserialize(allocator, T, deserializer, v.visitor());
+    return try db.deserialize(a, T, d, v.visitor());
 }
 
 fn PointVisitor(comptime Value: type) type {
diff --git a/src/ser/serialize.zig b/src/ser/serialize.zig
index 3ec48a55..3e615cef 100644
--- a/src/ser/serialize.zig
+++ b/src/ser/serialize.zig
@@ -10,17 +10,17 @@ const t = @import("testing.zig");
 /// Serializes `v` using a `getty.Serializer` `s`.
 pub fn serialize(
     /// An optional memory allocator.
-    allocator: ?std.mem.Allocator,
+    a: ?std.mem.Allocator,
     /// A value to serialize.
-    value: anytype,
+    v: anytype,
     /// A `getty.Serializer` interface value.
-    serializer: anytype,
-) @TypeOf(serializer).Error!@TypeOf(serializer).Ok {
-    const T = @TypeOf(value);
+    s: anytype,
+) @TypeOf(s).Error!@TypeOf(s).Ok {
+    const T = @TypeOf(v);
 
     const block = comptime blk: {
         // Process user SBs.
-        for (@TypeOf(serializer).user_st) |sb| {
+        for (@TypeOf(s).user_st) |sb| {
             if (sb.is(T)) {
                 break :blk sb;
             }
@@ -32,7 +32,7 @@ pub fn serialize(
         }
 
         // Process serializer SBs.
-        for (@TypeOf(serializer).serializer_st) |sb| {
+        for (@TypeOf(s).serializer_st) |sb| {
             if (sb.is(T)) {
                 break :blk sb;
             }
@@ -51,14 +51,14 @@ pub fn serialize(
     // Process attributes, if any exist.
     if (comptime attributes.has_attributes(T, block)) {
         switch (@typeInfo(T)) {
-            .Enum => return try blocks.Enum.serialize(allocator, value, serializer),
-            .Struct => return try blocks.Struct.serialize(allocator, value, serializer),
-            .Union => return try blocks.Union.serialize(allocator, value, serializer),
+            .Enum => return try blocks.Enum.serialize(a, v, s),
+            .Struct => return try blocks.Struct.serialize(a, v, s),
+            .Union => return try blocks.Union.serialize(a, v, s),
             else => @compileError("unexpected type cannot be serialized using attributes"),
         }
     }
 
-    return try block.serialize(allocator, value, serializer);
+    return try block.serialize(a, v, s);
 }
 
 test "serialize - success, normal" {