chore: add example and improve readme

Author: thevilledev

README.md

@@ -1,26 +1,40 @@
 # ChibiHash64-Zig
 
-A Zig port of [ChibiHash64](https://github.com/N-R-K/ChibiHash) - a small, fast 64-bit hash function.
+A Zig port of [ChibiHash64](https://github.com/N-R-K/ChibiHash) - a small, fast 64-bit hash function. See the article [ChibiHash: A small, fast 64-bit hash function](https://nrk.neocities.org/articles/chibihash) for more information.
+
+All credit for the algorithm goes to [N-R-K](https://github.com/N-R-K).
 
 ## Features
+
 - Simple 64-bit hash function
+- Supports both v1 and v2 of the hash function
 - HashMap implementation
 - Thoroughly tested with known test vectors
 
 ## Usage
 
 ```
 const std = @import("std");
-const ChibiHash64 = @import("chibihash64.zig");
+const ChibiHash64v1 = @import("chibihash64_v1.zig");
+const ChibiHash64v2 = @import("chibihash64_v2.zig");
+
+// Basic hashing v1
+const hash = ChibiHash64v1.hash("Hello, world!", 0);
 
-// Basic hashing
-const hash = ChibiHash64.hash("Hello, world!", 0);
+// Using HashMap v1
+var map = ChibiHash64v1.HashMap([]const u8, i32).init(allocator);
+defer map.deinit();
+
+// Basic hashing v2
+const hash = ChibiHash64v2.hash("Hello, world!", 0);
 
-// Using HashMap
-var map = ChibiHash64.HashMap([]const u8, i32).init(allocator);
+// Using HashMap v2
+var map = ChibiHash64v2.HashMap([]const u8, i32).init(allocator);
 defer map.deinit();
 ```
 
+See `example/example.zig` for a complete example. Run it with `zig build run-example`.
+
 ## License
 
 MIT.

build.zig

@@ -68,4 +68,32 @@ pub fn build(b: *std.Build) void {
     const docs_step = b.step("docs", "Generate library documentation");
     docs_step.dependOn(&lib_v1_docs.step);
     docs_step.dependOn(&lib_v2_docs.step);
+
+    // Create example executable
+    const example = b.addExecutable(.{
+        .name = "example",
+        .root_source_file = .{ .cwd_relative = "example/example.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Create modules
+    const chibihash64_v1 = b.addModule("chibihash64_v1", .{
+        .root_source_file = .{ .cwd_relative = "src/chibihash64_v1.zig" },
+    });
+    const chibihash64_v2 = b.addModule("chibihash64_v2", .{
+        .root_source_file = .{ .cwd_relative = "src/chibihash64_v2.zig" },
+    });
+
+    // Add module dependencies to example
+    example.root_module.addImport("chibihash64_v1", chibihash64_v1);
+    example.root_module.addImport("chibihash64_v2", chibihash64_v2);
+
+    // Install the example
+    b.installArtifact(example);
+
+    // Create a run step for the example
+    const run_example = b.addRunArtifact(example);
+    const run_step = b.step("run-example", "Run the example program");
+    run_step.dependOn(&run_example.step);
 }

example/example.zig

@@ -0,0 +1,30 @@
+const std = @import("std");
+const ChibiHash64v1 = @import("chibihash64_v1");
+const ChibiHash64v2 = @import("chibihash64_v2");
+
+pub fn main() !void {
+    // Get an allocator
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Basic hashing v1
+    const hash_v1 = ChibiHash64v1.chibihash64("Hello, world!", 0);
+    std.debug.print("V1 hash of 'Hello, world!': 0x{X}\n", .{hash_v1});
+
+    // Using HashMap v1
+    var map_v1 = ChibiHash64v1.HashMap([]const u8, i32).init(allocator);
+    defer map_v1.deinit();
+    try map_v1.put("example", 42);
+    std.debug.print("V1 HashMap get 'example': {?}\n", .{map_v1.get("example")});
+
+    // Basic hashing v2
+    const hash_v2 = ChibiHash64v2.chibihash64("Hello, world!", 0);
+    std.debug.print("V2 hash of 'Hello, world!': 0x{X}\n", .{hash_v2});
+
+    // Using HashMap v2
+    var map_v2 = ChibiHash64v2.HashMap([]const u8, i32).init(allocator);
+    defer map_v2.deinit();
+    try map_v2.put("example", 42);
+    std.debug.print("V2 HashMap get 'example': {?}\n", .{map_v2.get("example")});
+}