Implicit conversion/Variant

Author: ratulb

codes/cyclic_reference_1.mojo

@@ -0,0 +1,15 @@
+# We have no issues Referece1 calling Reference2 which also calls Reference1
+from cyclic_reference_2 import Reference2
+
+
+struct Reference1:
+    fn __init__(out self):
+        Reference2.print("Reference2 inside Reference1 constructor")
+
+    @staticmethod
+    fn print(s: String):
+        print(s)
+
+
+fn main():
+    var ref1 = Reference1()

codes/cyclic_reference_2.mojo

@@ -0,0 +1,16 @@
+# We have no issues Referece2 calling Reference1 which also calls Reference2
+
+from cyclic_reference_1 import Reference1
+
+
+struct Reference2:
+    fn __init__(out self):
+        Reference1.print("Reference1 inside Reference2 constructor")
+
+    @staticmethod
+    fn print(s: String):
+        print(s)
+
+
+fn main():
+    var ref2 = Reference2()

codes/game_of_life.mojo

@@ -1,17 +1,36 @@
-from gridv1 import Grid
+from gridv1 import Grid as GridV1
+from gridv2 import Grid as GridV2
+from utils import Variant
+import random
+
+alias Grid = Variant[GridV1, GridV2]
 
 
 fn run(owned grid: Grid) raises -> None:
+    var inner: GridV1
+    if grid.isa[GridV1]():
+        inner = grid[GridV1]
+        print("Received a grid of type V1")
+    else:
+        inner = GridV1(grid[GridV2])
+        print("Received a grid of type V2 - converted to V1")
     while True:
         print("Current mutation:\n\n")
-        print(grid)
+        print(inner)
         print()
         print()
         if input("Enter 'q' to quit or press <Enter> to continue: ") == "q":
             break
-        grid.mutate()
+        inner.mutate()
 
 
 fn main() raises -> None:
-    start = Grid.new(16, 16)
-    run(start)
+    random.seed()
+    var grid: Grid
+    if random.random_ui64(0, 1):
+        v1 = GridV1.new(16, 16)
+        grid = Grid(v1)
+    else:
+        v2 = GridV2.new(None, 16, 16)
+        grid = Grid(v2)
+    run(grid^)

codes/gridv1.mojo

@@ -1,4 +1,5 @@
 import random
+from gridv2 import Grid as GridV2
 
 
 # Grid is a 2D structure holding cell states (0: dead, 1: alive)
@@ -11,6 +12,19 @@ struct Grid(Stringable, Writable):
     fn __init__(out self, data: List[List[Int, True]]):
         self.data = data
 
+    @implicit
+    fn __init__(out self, source: GridV2):
+        data = source.data
+        rows = source.rows
+        cols = source.cols
+        grid = List[List[Int, True]]()
+        for row in range(rows):
+            curr_row = List[Int, True]()
+            for col in range(cols):
+                curr_row.append(Int((data + (row * cols + col))[]))
+            grid.append(curr_row)
+        self.data = grid^
+
     # Get the number of rows in the grid
     fn row_count(self) -> Int:
         if self.data:
@@ -106,6 +120,7 @@ struct Grid(Stringable, Writable):
                 if self[row, col] == 0 and alive_neighbours == 3:
                     self[row, col] = 1
 
+
 fn run(owned grid: Grid) raises -> None:
     while True:
         print("Current mutation:\n\n")
@@ -118,5 +133,9 @@ fn run(owned grid: Grid) raises -> None:
 
 
 fn main() raises -> None:
-    start = Grid.new(16, 16)
-    run(start)
+    grid_2 = GridV2.new(42, 16, 16)
+    #run(grid_2)
+    print(grid_2)
+    print("Implicit conversion\n\n")
+    grid_1 = Grid(grid_2)
+    print(grid_1)

codes/gridv2.mojo

@@ -1,8 +1,7 @@
 import random
 from collections import Optional
 from memory import UnsafePointer, memcpy, memset_zero
-from gridv1 import Grid as Grid1
-
+from gridv1 import Grid as GridV1
 
 struct Grid(Stringable, Writable):
     var data: UnsafePointer[UInt8]
@@ -14,6 +13,15 @@ struct Grid(Stringable, Writable):
         self.cols = cols
         self.data = UnsafePointer[UInt8].alloc(rows * cols)
 
+    fn __init__(out self, source: GridV1):
+        rows = len(source.data)
+        cols = len(source.data[0])
+        self = Self(rows, cols)
+        for row in range(rows):
+            for col in range(cols):
+                value = UInt8(source[row, col])
+                (self.data + row * cols + col)[] = value
+
     fn __copyinit__(out self, existing: Self):
         self.rows = existing.rows
         self.cols = existing.cols
@@ -104,14 +112,9 @@ fn run(owned grid: Grid) raises -> None:
 
 
 fn main() raises -> None:
-    grid1 = Grid.new(None, 16, 16)
-    print("s1: \n")
-    print(grid1)
-    grid = Grid.new(None, 0, 0)
-    g = grid.__moveinit__(grid1^)
-    print("s2: \n")
-    print(g)
-    # run(grid)
-    grid1 = g.__copyinit__(g)
-    print("s3: \n")
-    print(grid1)
+    grid_1 = GridV1.new(16, 16)
+    # run(grid_1)
+    print(grid_1)
+    print("Implicit conversion\n\n")
+    grid_2 = Grid(grid_1)
+    print(grid_2)