Proper module structure

Author: Kaweees

.justfile

@@ -29,7 +29,7 @@ run:
 # Test the project
 test:
   @echo "Testing..."
-  @zig build test
+  @zig build test --summary all
 
 # Remove build artifacts and non-essential files
 clean:

build.zig

@@ -42,26 +42,12 @@ pub fn build(b: *std.Build) void {
     // Modules can depend on one another using the `std.Build.Module.addImport` function.
     // This is what allows Zig source code to use `@import("foo")` where 'foo' is not a
     // file path. In this case, we set up `exe_mod` to import `lib_mod`.
-    exe_mod.addImport("micrograd_lib", lib_mod);
-
-    // Now, we will create a static library based on the module we created above.
-    // This creates a `std.Build.Step.Compile`, which is the build step responsible
-    // for actually invoking the compiler.
-    const lib = b.addLibrary(.{
-        .linkage = .static,
-        .name = "micrograd",
-        .root_module = lib_mod,
-    });
-
-    // This declares intent for the library to be installed into the standard
-    // location when the user invokes the "install" step (the default step when
-    // running `zig build`).
-    b.installArtifact(lib);
+    exe_mod.addImport("micrograd", lib_mod);
 
     // This creates another `std.Build.Step.Compile`, but this one builds an executable
     // rather than a static library.
     const exe = b.addExecutable(.{
-        .name = "micrograd",
+        .name = "train",
         .root_module = exe_mod,
     });
 

src/engine.zig

@@ -1,7 +1,6 @@
-//! This file provides
+//! This file provides engine functionality for micrograd
 
 const std = @import("std");
-const arch = @import("../arch/arch.zig");
 
 /// Operations for the engine
 pub const Operation = enum(u8) {
@@ -28,6 +27,11 @@ pub fn Value(comptime T: type) type {
             };
         }
 
+        /// Convert the Value to a string
+        pub fn toString(self: @This()) []const u8 {
+            return std.fmt.allocPrint(std.heap.page_allocator, "Value(value={any})", .{self.value}) catch unreachable;
+        }
+
         /// Add two values
         pub fn add(self: @This(), other: @This()) @This() {
             return @This(){

src/main.zig

@@ -2,15 +2,17 @@
 //! you are building an executable. If you are making a library, the convention
 //! is to delete this file and start with root.zig instead.
 
-const engine = @import("engine.zig");
+const std = @import("std");
+/// This imports the separate module containing `root.zig`. Take a look in `build.zig` for details.
+const lib = @import("micrograd");
 
 pub fn main() !void {
-    const value = engine.Value(f32).init(3.14);
+    const value = lib.engine.Value(f32).init(3.14);
 
-    std.debug.print("Value: {}\n", .{value});
+    std.debug.print("{s}\n", .{value.toString()});
 
-    const value2 = engine.Value(i32).init(0x01);
-    std.debug.print("Value2: {}\n", .{value2});
+    const value2 = lib.engine.Value(i32).init(0x01);
+    std.debug.print("{s}\n", .{value2.toString()});
 
     // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`)
     std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
@@ -48,8 +50,3 @@ test "fuzz example" {
     };
     try std.testing.fuzz(Context{}, Context.testOne, .{});
 }
-
-const std = @import("std");
-
-/// This imports the separate module containing `root.zig`. Take a look in `build.zig` for details.
-const lib = @import("micrograd_lib");

src/root.zig

@@ -3,6 +3,7 @@
 //! start with main.zig instead.
 const std = @import("std");
 const testing = std.testing;
+pub const engine = @import("engine.zig");
 
 pub export fn add(a: i32, b: i32) i32 {
     return a + b;