1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
// Conway's Game of Life - Simple Working Version
// Get element at index from list (safe)
at : xs i ->
when (i >= 0 and i < length xs) is
true then slice xs i (i + 1).0
_ then 0;
// Get 2D element from grid (safe)
get2d : grid row col ->
when (row >= 0 and row < length grid and col >= 0) is
true then
with (rowData : at grid row) ->
when (col < length rowData) is
true then at rowData col
_ then 0
_ then 0;
// Count living neighbors around position (row, col)
countNeighbors : grid row col ->
with (
n1 : get2d grid (row - 1) (col - 1);
n2 : get2d grid (row - 1) col;
n3 : get2d grid (row - 1) (col + 1);
n4 : get2d grid row (col - 1);
n5 : get2d grid row (col + 1);
n6 : get2d grid (row + 1) (col - 1);
n7 : get2d grid (row + 1) col;
n8 : get2d grid (row + 1) (col + 1);
) -> n1 + n2 + n3 + n4 + n5 + n6 + n7 + n8;
// Apply Game of Life rules to a single cell
nextCellState : grid row col ->
with (
current : get2d grid row col;
neighbors : countNeighbors grid row col;
) ->
when current is
1 then
when (neighbors = 2 or neighbors = 3) is
true then 1
_ then 0
_ then
when (neighbors = 3) is
true then 1
_ then 0;
// Generate next generation of the entire grid
nextGeneration : grid ->
with (
height : length grid;
width : length (at grid 0);
// Create new grid row by row
newRow : rowIdx ->
with (
newCol : colIdx -> nextCellState grid rowIdx colIdx;
cols : [0, 1, 2, 3, 4]; // Assuming 5x5 for now
) -> map newCol cols;
rows : [0, 1, 2, 3, 4]; // Assuming 5x5 for now
) -> map newRow rows;
// Print a single row
printRow : row ->
with (
cellToChar : cell -> when cell is 1 then "#" _ then ".";
chars : map cellToChar row;
) -> io.out chars;
// Print entire grid with title
printGrid : grid title ->
with (
_ : io.out "";
_ : io.out title;
_ : io.out "-----";
_ : map printRow grid;
) -> 0; // Return dummy value
// Test patterns
// Glider pattern (moves diagonally)
glider : [
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[1, 1, 1, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]
];
// Blinker pattern (oscillates)
blinker : [
[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]
];
// Run simulations
io.out "Conway's Game of Life";
io.out "====================";
// Show initial glider
dummy1 : printGrid glider "Glider - Generation 0";
g1 : nextGeneration glider;
dummy2 : printGrid g1 "Glider - Generation 1";
g2 : nextGeneration g1;
dummy3 : printGrid g2 "Glider - Generation 2";
// Show blinker oscillation
dummy4 : printGrid blinker "Blinker - Generation 0";
b1 : nextGeneration blinker;
dummy5 : printGrid b1 "Blinker - Generation 1";
b2 : nextGeneration b1;
dummy6 : printGrid b2 "Blinker - Generation 2";
io.out "Done!";
|