Update all implicit type casts to be explicit (#237)

* Update all implicit type casts to be explicit reusing dtype var where possible
* Remove redundant Int() casts around block_dim, block_idx, and thread_idx
* Wrap both values in a cast for a single dtype across an operation.

Author: dunnoconnor

book/src/puzzle_26/puzzle_26.md

@@ -115,7 +115,7 @@ Learn XOR-based butterfly communication patterns for efficient tree algorithms a
 max_val = input[global_i]
 offset = WARP_SIZE // 2
 while offset > 0:
-    max_val = max(max_val, shuffle_xor(max_val, offset))
+    max_val = max(max_val, shuffle_xor(max_val, UInt32(offset)))
     offset //= 2
 # All lanes now have global maximum
 ```

book/src/puzzle_26/warp_prefix_sum.md

@@ -391,7 +391,7 @@ if global_i < size:
     # Butterfly reduction to get total across the warp: dynamic for any WARP_SIZE
     offset = WARP_SIZE // 2
     while offset > 0:
-        warp_left_total += shuffle_xor(warp_left_total, offset)
+        warp_left_total += shuffle_xor(warp_left_total, UInt32(offset))
         offset //= 2
 
     # Phase 4: Write to output positions

book/src/puzzle_26/warp_shuffle_xor.md

@@ -406,7 +406,7 @@ if global_i < size:
     # Butterfly reduction tree: dynamic for any WARP_SIZE
     offset = WARP_SIZE // 2
     while offset > 0:
-        max_val = max(max_val, shuffle_xor(max_val, offset))
+        max_val = max(max_val, shuffle_xor(max_val, UInt32(offset)))
         offset //= 2
 
     output[global_i] = max_val  # All lanes have global maximum
@@ -599,10 +599,10 @@ if global_i < size:
     # Butterfly reduction for both max and min log_2(WARP_SIZE}) steps)
     offset = WARP_SIZE // 2
     while offset > 0:
-        neighbor_val = shuffle_xor(current_val, offset)
+        neighbor_val = shuffle_xor(current_val, UInt32(offset))
         current_val = max(current_val, neighbor_val)    # Max reduction
 
-        min_neighbor_val = shuffle_xor(min_val, offset)
+        min_neighbor_val = shuffle_xor(min_val, UInt32(offset))
         min_val = min(min_val, min_neighbor_val)        # Min reduction
 
         offset //= 2
@@ -643,10 +643,10 @@ Final result: All lanes have current_val=7 (global max) and min_val=1 (global mi
 ```mojo
 offset = WARP_SIZE // 2
 while offset > 0:
-    neighbor_val = shuffle_xor(current_val, offset)
+    neighbor_val = shuffle_xor(current_val, UInt32(offset))
     current_val = max(current_val, neighbor_val)
 
-    min_neighbor_val = shuffle_xor(min_val, offset)
+    min_neighbor_val = shuffle_xor(min_val, UInt32(offset))
     min_val = min(min_val, min_neighbor_val)
 
     offset //= 2
@@ -710,7 +710,7 @@ The `shuffle_xor()` primitive enables powerful butterfly communication patterns
 ```mojo
 offset = WARP_SIZE // 2
 while offset > 0:
-    neighbor_val = shuffle_xor(current_val, offset)
+    neighbor_val = shuffle_xor(current_val, UInt32(offset))
     current_val = operation(current_val, neighbor_val)
     offset //= 2
 ```

book/src/puzzle_27/block_prefix_sum.md

@@ -92,7 +92,7 @@ To classify a `Float32` value into bins:
 
 ```mojo
 my_value = input_data[global_i][0]  # Extract SIMD like in dot product
-bin_number = Int(floor(my_value * num_bins))
+bin_number = Int(floor(my_value * Float32(num_bins)))
 ```
 
 **Edge case handling**: Values exactly 1.0 would go to bin `NUM_BINS`, but you only have bins 0 to `NUM_BINS-1`. Use an `if` statement to clamp the maximum bin.
@@ -140,7 +140,7 @@ The last thread (not thread 0!) computes the total count:
 
 ```mojo
 if local_i == tpb - 1:  # Last thread in block
-    total_count = offset[0] + belongs_to_target  # Inclusive = exclusive + own contribution
+    total_count = offset[0] + Int32(belongs_to_target)  # Inclusive = exclusive + own contribution
     count_output[0] = total_count
 ```
 
@@ -322,7 +322,7 @@ Result: [0.00, 0.01, 0.02, ..., 0.12, ???, ???, ...] // Perfectly packed!
 ```
 Last thread computes total (not thread 0!):
   if local_i == tpb - 1:  // Thread 127 in our case
-      total = write_offset[0] + belongs_to_target  // Inclusive sum formula
+      total = write_offset[0] + Int32(belongs_to_target)  // Inclusive sum formula
       count_output[0] = total
 ```
 

book/src/puzzle_29/memory_barrier.md

@@ -327,7 +327,7 @@ stencil_count = 0
 for neighbor in valid_neighbors:
     stencil_sum += buffer[neighbor]
     stencil_count += 1
-result[i] = stencil_sum / stencil_count
+result[i] = stencil_sum / Float32(stencil_count)
 ```
 
 ## **Buffer role alternation**

pixi.toml

@@ -40,7 +40,7 @@ system-requirements = { macos = "15.0" }
 [dependencies]
 python = "==3.12"
 mojo = "<1.0.0" # includes `mojo-compiler`, lsp, debugger, formatter etc.
-max = "==26.3.0.dev2026032405"
+max = "==26.3.0.dev2026033105"
 bash = ">=5.2.21,<6"
 manim = ">=0.18.1,<0.19"
 mdbook = ">=0.4.48,<0.5"

problems/p01/p01.mojo

@@ -29,7 +29,7 @@ def main() raises:
         a.enqueue_fill(0)
         with a.map_to_host() as a_host:
             for i in range(SIZE):
-                a_host[i] = i
+                a_host[i] = Scalar[dtype](i)
 
         ctx.enqueue_function[add_10, add_10](
             out,
@@ -43,7 +43,7 @@ def main() raises:
         ctx.synchronize()
 
         for i in range(SIZE):
-            expected[i] = i + 10
+            expected[i] = Scalar[dtype](i + 10)
 
         with out.map_to_host() as out_host:
             print("out:", out_host)

problems/p02/p02.mojo

@@ -34,8 +34,8 @@ def main() raises:
         expected.enqueue_fill(0)
         with a.map_to_host() as a_host, b.map_to_host() as b_host:
             for i in range(SIZE):
-                a_host[i] = i
-                b_host[i] = i
+                a_host[i] = Scalar[dtype](i)
+                b_host[i] = Scalar[dtype](i)
                 expected[i] = a_host[i] + b_host[i]
 
         ctx.enqueue_function[add, add](

problems/p03/p03.mojo

@@ -13,7 +13,7 @@ comptime dtype = DType.float32
 def add_10_guard(
     output: UnsafePointer[Scalar[dtype], MutAnyOrigin],
     a: UnsafePointer[Scalar[dtype], MutAnyOrigin],
-    size: UInt,
+    size: Int,
 ):
     var i = thread_idx.x
     # FILL ME IN (roughly 2 lines)
@@ -30,12 +30,12 @@ def main() raises:
         a.enqueue_fill(0)
         with a.map_to_host() as a_host:
             for i in range(SIZE):
-                a_host[i] = i
+                a_host[i] = Scalar[dtype](i)
 
         ctx.enqueue_function[add_10_guard, add_10_guard](
             out,
             a,
-            UInt(SIZE),
+            SIZE,
             grid_dim=BLOCKS_PER_GRID,
             block_dim=THREADS_PER_BLOCK,
         )
@@ -45,7 +45,7 @@ def main() raises:
         ctx.synchronize()
 
         for i in range(SIZE):
-            expected[i] = i + 10
+            expected[i] = Scalar[dtype](i + 10)
 
         with out.map_to_host() as out_host:
             print("out:", out_host)

problems/p04/p04.mojo

@@ -13,7 +13,7 @@ comptime dtype = DType.float32
 def add_10_2d(
     output: UnsafePointer[Scalar[dtype], MutAnyOrigin],
     a: UnsafePointer[Scalar[dtype], MutAnyOrigin],
-    size: UInt,
+    size: Int,
 ):
     var row = thread_idx.y
     var col = thread_idx.x
@@ -35,13 +35,13 @@ def main() raises:
             # row-major
             for i in range(SIZE):
                 for j in range(SIZE):
-                    a_host[i * SIZE + j] = i * SIZE + j
+                    a_host[i * SIZE + j] = Scalar[dtype](i * SIZE + j)
                     expected[i * SIZE + j] = a_host[i * SIZE + j] + 10
 
         ctx.enqueue_function[add_10_2d, add_10_2d](
             out,
             a,
-            UInt(SIZE),
+            SIZE,
             grid_dim=BLOCKS_PER_GRID,
             block_dim=THREADS_PER_BLOCK,
         )