add mirroring

src/doodler.gleam

···
 }
 
 fn init(_flags) {
-  Model(starting_points(), [], None)
+  Model(starting_points(), [], None, Both)
 }
 
 type Model {
-  Model(points: Set(Point), edges: List(Edge), selected: Option(Point))
+  Model(
+    points: Set(Point),
+    edges: List(Edge),
+    selected: Option(Point),
+    mirroring: Mirroring,
+  )
 }
 
 type Point {
···
   Edge(a: Point, b: Point)
 }
 
+type Mirroring {
+  Off
+  Vertical
+  Horizontal
+  Both
+}
+
 type Msg {
   UserClickedPoint(Point)
   // TODO: implement mirror toggle
   // For horizontal / vertical mirroring
+  UserClickedToggleMirror
   // TODO: implement 'shape verification mode' toggle
 }
 
 fn starting_points() {
-  set.from_list([
-    Point(0, 0),
-    Point(0, 1),
-    Point(0, -1),
-    Point(-1, 0),
-    Point(-1, -1),
-    Point(1, 0),
-    Point(1, -1),
-  ])
+  set.from_list(add_point_neighbors(set.new(), Point(0, 0)) |> set.to_list())
 }
 
 fn update(model: Model, msg: Msg) {
···
     UserClickedPoint(clicked_point) -> {
       case model {
         // no point selected, select the clicked one
-        Model(points: _, edges:, selected: None) -> {
+        Model(points: _, edges:, selected: None, mirroring:) -> {
           let points =
-            update_points(edges)
+            edges
+            |> update_points
             |> add_point_neighbors(clicked_point)
 
-          Model(points:, edges:, selected: Some(clicked_point))
+          Model(points:, edges:, selected: Some(clicked_point), mirroring:)
         }
         // same point clicked again, deselect it
-        Model(points: _, edges:, selected: Some(first_point))
+        Model(points: _, edges:, selected: Some(first_point), mirroring:)
           if clicked_point == first_point
         -> {
           let points = update_points(edges)
-          Model(points, edges, selected: None)
+          Model(points, edges, selected: None, mirroring:)
         }
 
         // different point selected, add / remove that edge
-        Model(_, _, Some(first_point)) -> {
-          // doesnt work
-          let thing =
+        Model(_, _, Some(first_point), mirroring:) -> {
+          let filtered_edges =
             model.edges
-            |> list.partition(fn(edge) {
-              {
-                points_equal(edge.a, first_point)
-                && points_equal(edge.b, clicked_point)
-              }
-              || {
-                points_equal(edge.a, clicked_point)
-                && points_equal(edge.b, first_point)
-              }
-            })
+            |> list.partition(filter_edge(
+              _,
+              first_point,
+              clicked_point,
+              mirroring,
+            ))
 
-          let edges = case thing {
+          let edges = case filtered_edges {
             // the new edge wasnt found in the existing ones, add it
-            #([], edges) -> [Edge(first_point, clicked_point), ..edges]
+            #([], edges) ->
+              add_new_edge(first_point, clicked_point, edges, mirroring)
             // the new edge was found in the existing ones, remove it
             #([_, ..], edges) -> edges
           }
           let points = update_points(edges)
           // let points = model.points
 
-          Model(points:, edges:, selected: None)
+          Model(points:, edges:, selected: None, mirroring:)
         }
       }
     }
+    // cycle mirroring
+    UserClickedToggleMirror ->
+      case model {
+        Model(_, _, _, Off) -> Model(..model, mirroring: Vertical)
+        Model(_, _, _, Vertical) -> Model(..model, mirroring: Horizontal)
+        Model(_, _, _, Horizontal) -> Model(..model, mirroring: Both)
+        Model(_, _, _, Both) -> Model(..model, mirroring: Off)
+      }
+  }
+}
+
+fn add_new_edge(
+  point_a: Point,
+  point_b: Point,
+  edges: List(Edge),
+  mirroring: Mirroring,
+) -> List(Edge) {
+  case mirroring {
+    Off -> [Edge(point_a, point_b)]
+    Vertical -> [
+      Edge(point_a, point_b),
+      Edge(point_a, point_b) |> invert_y,
+    ]
+    Horizontal -> [
+      Edge(point_a, point_b),
+      Edge(point_a, point_b) |> invert_x,
+    ]
+    Both -> [
+      Edge(point_a, point_b),
+      Edge(point_a, point_b) |> invert_x,
+      Edge(point_a, point_b) |> invert_y,
+      Edge(point_a, point_b) |> invert_x |> invert_y(),
+    ]
+  }
+  |> list.append(edges)
+}
+
+fn invert_x(edge: Edge) -> Edge {
+  let Edge(a, b) = edge
+
+  Edge(Point(-a.x, a.y), Point(-b.x, b.y))
+}
+
+fn invert_y(edge: Edge) -> Edge {
+  let Edge(a, b) = edge
+
+  Edge(Point(a.x, -a.y), Point(b.x, -b.y))
+}
+
+fn filter_edge(edge: Edge, point_a, point_b, mirroring) {
+  {
+    points_equal_respect_mirror(edge.a, point_a, mirroring)
+    && points_equal_respect_mirror(edge.b, point_b, mirroring)
+  }
+  || {
+    points_equal_respect_mirror(edge.a, point_b, mirroring)
+    && points_equal_respect_mirror(edge.b, point_a, mirroring)
   }
 }
 
···
   first_point.x == second_point.x && first_point.y == second_point.y
 }
 
+/// compare two points for equality; while respecting Mirroring
+///
+fn points_equal_respect_mirror(
+  first_point: Point,
+  second_point: Point,
+  mirroring: Mirroring,
+) -> Bool {
+  case mirroring {
+    Off -> first_point.x == second_point.x && first_point.y == second_point.y
+    Vertical ->
+      first_point.x == second_point.x
+      && int.absolute_value(first_point.y) == int.absolute_value(second_point.y)
+    Horizontal ->
+      int.absolute_value(first_point.x) == int.absolute_value(second_point.x)
+      && first_point.y == second_point.y
+    Both ->
+      int.absolute_value(first_point.x) == int.absolute_value(second_point.x)
+      && int.absolute_value(first_point.y) == int.absolute_value(second_point.y)
+  }
+}
+
 /// get #(min_x, min_y, max_x, max_y) from a list of points
 ///
 fn min_max(points) {
···
   div([], [
     svg.svg(
       [
-        attribute.attribute("width", "100vw"),
-        attribute.attribute("height", "100vh"),
+        attribute.attribute("width", "100%"),
+        attribute.attribute("height", "100%"),
         attribute.attribute("viewBox", viewbox),
       ],
       list.append(