megamanmalte/visual-queens - Change PUEVD5LHJH2GUKOBNHZTGYW6YTIBZGE7AMAHPDMMGSCUQFULII2AC

Distinction between queens and auto-solving

Created by Maurizio_Bruetsch on December 16, 2020

PUEVD5LHJH2GUKOBNHZTGYW6YTIBZGE7AMAHPDMMGSCUQFULII2AC

Dependencies

In channels

main

Change contents

Replacement in frontend/static/queens.js at line 5369 [3.34]

B:BD[3.107382] → [2.0:82]

		{id: 1, queens: $elm$core$Set$empty, size: 8, status: $elm$core$Maybe$Nothing},

[3.107382]

[3.107388]

		{fixedQueens: $elm$core$Set$empty, id: 1, size: 8, solutionQueens: $elm$core$Set$empty, status: $elm$core$Maybe$Nothing},

Insertion in frontend/static/queens.js at line 5993 [3.34]

[4.7752]

	});
var $elm$core$List$filter = F2(
	function (isGood, list) {
		return A3(
			$elm$core$List$foldr,
			F2(
				function (x, xs) {
					return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
				}),
			_List_Nil,
			list);

Insertion in frontend/static/queens.js at line 6249 [3.34]

[4.14230]

[5.13060]

var $elm$core$Dict$member = F2(
	function (key, dict) {
		var _v0 = A2($elm$core$Dict$get, key, dict);
		if (_v0.$ === 'Just') {
			return true;
		} else {
			return false;
		}
	});
var $elm$core$Set$member = F2(
	function (key, _v0) {
		var dict = _v0.a;
		return A2($elm$core$Dict$member, key, dict);
	});
var $elm$core$Basics$not = _Basics_not;

Insertion in frontend/static/queens.js at line 6270 [3.34]

[5.13221]

[4.14231]

var $elm$core$Dict$sizeHelp = F2(
	function (n, dict) {
		sizeHelp:
		while (true) {
			if (dict.$ === 'RBEmpty_elm_builtin') {
				return n;
			} else {
				var left = dict.d;
				var right = dict.e;
				var $temp$n = A2($elm$core$Dict$sizeHelp, n + 1, right),
					$temp$dict = left;
				n = $temp$n;
				dict = $temp$dict;
				continue sizeHelp;
			}
		}
	});
var $elm$core$Dict$size = function (dict) {
	return A2($elm$core$Dict$sizeHelp, 0, dict);
};
var $elm$core$Set$size = function (_v0) {
	var dict = _v0.a;
	return $elm$core$Dict$size(dict);
};

Replacement in frontend/static/queens.js at line 6309 [3.34]

B:BD[2.363] → [2.363:596]

		var solveUrl = 'solve?id=1&size=' + ($elm$core$String$fromInt(model.size) + A3(
			$elm$core$List$foldl,
			$elm$core$Basics$append,
			'',
			A2(
				$elm$core$List$map,
				formatQueen,
				$elm$core$Set$toList(model.queens))));

[2.363]

[5.13222]

		var solveUrl = function (m) {
			return 'solve?id=1&size=' + ($elm$core$String$fromInt(m.size) + A3(
				$elm$core$List$foldl,
				$elm$core$Basics$append,
				'',
				A2(
					$elm$core$List$map,
					formatQueen,
					$elm$core$Set$toList(m.fixedQueens))));
		};
		var requestSolution = function (m) {
			return $elm$http$Http$get(
				{
					expect: A2($elm$http$Http$expectJson, $author$project$Queens$ReceivedSolution, $author$project$Queens$solutionDecoder),
					url: solveUrl(m)
				});
		};

Insertion in frontend/static/queens.js at line 6330 [3.34]

[5.13299]

				var newModel = _Utils_update(
					model,
					{
						fixedQueens: A2(
							$elm$core$Set$insert,
							_Utils_Tuple2(i, j),
							model.fixedQueens)
					});

Replacement in frontend/static/queens.js at line 6339 [3.34]

B:BD[5.13325] → [5.13325:13444]

B:BD[5.13444] → [2.597:659]

∅:D[2.659] → [5.13466:13511]

B:BD[5.13466] → [5.13466:13511]

					_Utils_update(
						model,
						{
							queens: A2(
								$elm$core$Set$insert,
								_Utils_Tuple2(i, j),
								model.queens),
							status: $elm$core$Maybe$Nothing
						}),
					$elm$core$Platform$Cmd$none);

[5.13325]

[5.13511]

					newModel,
					requestSolution(newModel));

Insertion in frontend/static/queens.js at line 6344 [3.34]

[5.13572]

				var newModel = _Utils_update(
					model,
					{
						fixedQueens: A2(
							$elm$core$Set$member,
							_Utils_Tuple2(i, j),
							model.solutionQueens) ? A2(
							$elm$core$Set$insert,
							_Utils_Tuple2(i, j),
							model.fixedQueens) : A2(
							$elm$core$Set$remove,
							_Utils_Tuple2(i, j),
							model.fixedQueens),
						solutionQueens: A2(
							$elm$core$Set$remove,
							_Utils_Tuple2(i, j),
							model.solutionQueens),
						status: $elm$core$Maybe$Nothing
					});

Replacement in frontend/static/queens.js at line 6364 [3.34]

B:BD[5.13598] → [5.13598:13717]

B:BD[5.13717] → [2.660:722]

∅:D[2.722] → [5.13739:13749]

B:BD[5.13739] → [5.13739:13749]

B:BD[5.13749] → [6.468:503]

					_Utils_update(
						model,
						{
							queens: A2(
								$elm$core$Set$remove,
								_Utils_Tuple2(i, j),
								model.queens),
							status: $elm$core$Maybe$Nothing
						}),
					$elm$core$Platform$Cmd$none);

[5.13598]

[6.503]

					newModel,
					requestSolution(newModel));

Replacement in frontend/static/queens.js at line 6370 [3.34]

B:BD[6.585] → [2.723:794]

						{queens: $elm$core$Set$empty, status: $elm$core$Maybe$Nothing}),

[6.585]

[5.13749]

						{fixedQueens: $elm$core$Set$empty, solutionQueens: $elm$core$Set$empty, status: $elm$core$Maybe$Nothing}),

Insertion in frontend/static/queens.js at line 6374 [3.34]

[4.14612]

				var newModel = _Utils_update(
					model,
					{
						fixedQueens: A2(
							$elm$core$Set$filter,
							function (_v1) {
								var x = _v1.a;
								var y = _v1.b;
								return (_Utils_cmp(x, size) < 0) && (_Utils_cmp(y, size) < 0);
							},
							model.fixedQueens),
						size: size,
						status: $elm$core$Maybe$Nothing
					});

Replacement in frontend/static/queens.js at line 6389 [3.34]

B:BD[4.14638] → [4.14638:14907]

B:BD[4.14907] → [2.795:853]

∅:D[2.853] → [4.14925:14970]

B:BD[4.14925] → [4.14925:14970]

					_Utils_update(
						model,
						{
							queens: A2(
								$elm$core$Set$filter,
								function (_v1) {
									var x = _v1.a;
									var y = _v1.b;
									return (_Utils_cmp(x, size) < 0) && (_Utils_cmp(y, size) < 0);
								},
								model.queens),
							size: size,
							status: $elm$core$Maybe$Nothing
						}),
					$elm$core$Platform$Cmd$none);

[4.14638]

[4.14970]

					newModel,
					($elm$core$Set$size(newModel.fixedQueens) > 0) ? requestSolution(newModel) : $elm$core$Platform$Cmd$none);

Replacement in frontend/static/queens.js at line 6394 [3.34]

B:BD[4.15025] → [4.15025:15185]

B:BD[4.15185] → [2.854:875]

∅:D[2.875] → [4.15255:15266]

B:BD[4.15255] → [4.15255:15266]

					$elm$http$Http$get(
						{
							expect: A2($elm$http$Http$expectJson, $author$project$Queens$ReceivedSolution, $author$project$Queens$solutionDecoder),
							url: solveUrl
						}));

[4.15025]

[4.15266]

					requestSolution(model));

Replacement in frontend/static/queens.js at line 6403 [3.34]
B:BD[4.15449] → [4.15449:15489]
```
								queens: $elm$core$Set$fromList(
```
[4.15449]
[4.15489]
```
								solutionQueens: $elm$core$Set$fromList(
```

Replacement in frontend/static/queens.js at line 6405 [3.34]

B:BD[4.15502] → [4.15502:15614]

										$elm$core$List$map,
										function (l) {
											return $author$project$Queens$listToTuple(l);

[4.15502]

[4.15614]

										$elm$core$List$filter,
										function (x) {
											return !A2($elm$core$Set$member, x, model.fixedQueens);

Replacement in frontend/static/queens.js at line 6409 [3.34]

B:BD[4.15627] → [2.876:893]

										sol)),

[4.15627]

[2.893]

										A2(
											$elm$core$List$map,
											function (l) {
												return $author$project$Queens$listToTuple(l);
											},
											sol))),

Insertion in frontend/static/queens.js at line 6424 [3.34]
[2.1033]
[2.1033]
```
								solutionQueens: $elm$core$Set$empty,
```
Deletion in frontend/static/queens.js at line 6437 [3.34]
B:BD[6.685] → [6.685:734]
```
var $author$project$Queens$Solve = {$: 'Solve'};
```

Insertion in frontend/static/queens.js at line 6474 [3.34]

[7.370]

[7.440]

var $elm$svg$Svg$Attributes$fillOpacity = _VirtualDom_attribute('fill-opacity');

Insertion in frontend/static/queens.js at line 6477 [3.34]
[5.14153]
[5.14153]
```
var $elm$svg$Svg$g = $elm$svg$Svg$trustedNode('g');
```

Deletion in frontend/static/queens.js at line 6571 [3.34]

B:BD[7.2304] → [7.2304:2308]

B:BD[7.2308] → [5.15618:15752]

B:BD[5.15752] → [4.17129:17272]

∅:D[4.17272] → [5.15837:15869]

B:BD[5.15837] → [5.15837:15869]

B:BD[5.15869] → [4.17273:17312]

∅:D[4.17312] → [5.15909:15941]

B:BD[5.15909] → [5.15909:15941]

B:BD[5.15941] → [4.17313:17352]

∅:D[4.17352] → [5.15981:16164]

B:BD[5.15981] → [5.15981:16164]

B:BD[5.16164] → [4.17353:17440]

∅:D[4.17440] → [5.16253:16345]

B:BD[5.16253] → [5.16253:16345]

	};
	var queen = function (_v0) {
		var i = _v0.a;
		var j = _v0.b;
		return A2(
			$elm$svg$Svg$foreignObject,
			_List_fromArray(
				[
					$elm$svg$Svg$Attributes$width(
					$elm$core$String$fromInt(w)),
					$elm$svg$Svg$Attributes$height(
					$elm$core$String$fromInt(w)),
					$elm$svg$Svg$Attributes$x(
					$elm$core$String$fromInt(i * w)),
					$elm$svg$Svg$Attributes$y(
					$elm$core$String$fromInt(j * w)),
					$elm$svg$Svg$Events$onClick(
					A2($author$project$Queens$RemoveQueen, i, j))
				]),
			_List_fromArray(
				[
					A2(
					$elm$html$Html$img,
					_List_fromArray(
						[
							$elm$html$Html$Attributes$width(w),
							$elm$html$Html$Attributes$height(w),
							$elm$html$Html$Attributes$src('static/queen.svg')
						]),
					_List_Nil)
				]));

Insertion in frontend/static/queens.js at line 6572 [3.34]

[5.16349]

	var queen = F2(
		function (color, _v0) {
			var i = _v0.a;
			var j = _v0.b;
			return A2(
				$elm$svg$Svg$g,
				_List_Nil,
				_List_fromArray(
					[
						A2(
						$elm$svg$Svg$foreignObject,
						_List_fromArray(
							[
								$elm$svg$Svg$Attributes$width(
								$elm$core$String$fromInt(w)),
								$elm$svg$Svg$Attributes$height(
								$elm$core$String$fromInt(w)),
								$elm$svg$Svg$Attributes$x(
								$elm$core$String$fromInt(i * w)),
								$elm$svg$Svg$Attributes$y(
								$elm$core$String$fromInt(j * w))
							]),
						_List_fromArray(
							[
								A2(
								$elm$html$Html$img,
								_List_fromArray(
									[
										$elm$html$Html$Attributes$width(w),
										$elm$html$Html$Attributes$height(w),
										$elm$html$Html$Attributes$src('static/queen.svg')
									]),
								_List_Nil)
							])),
						A2(
						$elm$svg$Svg$rect,
						_List_fromArray(
							[
								$elm$svg$Svg$Attributes$x(
								$elm$core$String$fromInt(i * w)),
								$elm$svg$Svg$Attributes$y(
								$elm$core$String$fromInt(j * w)),
								$elm$svg$Svg$Attributes$width(
								$elm$core$String$fromInt(w)),
								$elm$svg$Svg$Attributes$height(
								$elm$core$String$fromInt(w)),
								$elm$svg$Svg$Attributes$fillOpacity('0.0'),
								$elm$svg$Svg$Attributes$stroke(color),
								$elm$svg$Svg$Events$onClick(
								A2($author$project$Queens$RemoveQueen, i, j))
							]),
						_List_Nil)
					]));
		});

Replacement in frontend/static/queens.js at line 6693 [3.34]

B:BD[5.17532] → [5.17532:17622]

				A2(
					$elm$core$List$map,
					queen,
					$elm$core$Set$toList(model.queens)))));

[5.17532]

[6.1153]

				_Utils_ap(
					A2(
						$elm$core$List$map,
						queen('red'),
						$elm$core$Set$toList(model.fixedQueens)),
					A2(
						$elm$core$List$map,
						queen('none'),
						$elm$core$Set$toList(model.solutionQueens))))));

Deletion in frontend/static/queens.js at line 7000 [3.34]

B:BD[6.14236] → [6.14236:14544]

var $elm$core$Dict$member = F2(
	function (key, dict) {
		var _v0 = A2($elm$core$Dict$get, key, dict);
		if (_v0.$ === 'Just') {
			return true;
		} else {
			return false;
		}
	});
var $elm$core$Set$member = F2(
	function (key, _v0) {
		var dict = _v0.a;
		return A2($elm$core$Dict$member, key, dict);
	});

Deletion in frontend/static/queens.js at line 10023 [3.34]

B:BD[6.127667] → [6.127667:127892]

var $elm$core$List$filter = F2(
	function (isGood, list) {
		return A3(
			$elm$core$List$foldr,
			F2(
				function (x, xs) {
					return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
				}),
			_List_Nil,
			list);
	});

Deletion in frontend/static/queens.js at line 10328 [3.34]
B:BD[6.136758] → [6.136758:136798]
```
var $elm$core$Basics$not = _Basics_not;
```

Replacement in frontend/static/queens.js at line 13505 [3.34]

∅:D[4.43112] → [6.222780:222891]

B:BD[6.222780] → [6.222780:222891]

							A2(b, 'Clear', $author$project$Queens$ClearQueens),
							A2(b, 'Solve', $author$project$Queens$Solve)

[4.43112]

[6.222891]

							A2(b, 'Clear', $author$project$Queens$ClearQueens)

Replacement in frontend/src/Queens.elm at line 35 [3.108667]
∅:D[4.43276] → [5.17848:17882]
B:BD[7.4192] → [5.17848:17882]
```
    , queens : Set.Set (Int, Int)
```
[4.43276]
[2.1862]
```
    , fixedQueens : Set.Set (Int, Int)
    , solutionQueens : Set.Set (Int, Int)
```
Replacement in frontend/src/Queens.elm at line 56 [3.108667]
B:BD[5.17983] → [5.17983:18010]
```
      , queens = Set.empty
```
[5.17983]
[4.43366]
```
      , fixedQueens = Set.empty
      , solutionQueens = Set.empty
```
Replacement in frontend/src/Queens.elm at line 70 [3.108667]
B:BD[2.1962] → [2.1962:1982]
```
        solveUrl = 
```
[2.1962]
[2.1982]
```
        solveUrl m = 
```

Replacement in frontend/src/Queens.elm at line 72 [3.108667]

B:BD[2.2014] → [2.2014:2142]

            ++ String.fromInt model.size 
            ++ (List.foldl (++) "" <| List.map formatQueen (Set.toList model.queens))

[2.2014]

[5.18041]

            ++ String.fromInt m.size 
            ++ (List.foldl (++) "" <| List.map formatQueen (Set.toList m.fixedQueens))
        requestSolution m = 
            Http.get 
                { url = solveUrl m
                , expect = Http.expectJson ReceivedSolution solutionDecoder
                }

Replacement in frontend/src/Queens.elm at line 85 [3.108667]

B:BD[5.18144] → [2.2256:2383]

            AddQueen i j
                -> ( { model | queens = Set.insert (i,j) model.queens, status = Nothing }, Cmd.none )

[5.18144]

[6.223219]

            AddQueen i j ->
                let 
                    newModel = { model | fixedQueens = Set.insert (i,j) model.fixedQueens }
                in
                    ( newModel, requestSolution newModel )

Replacement in frontend/src/Queens.elm at line 91 [3.108667]

B:BD[6.223220] → [2.2384:2514]

∅:D[2.2514] → [4.43384:43385]

B:BD[6.223300] → [4.43384:43385]

B:BD[4.43385] → [2.2515:2621]

            RemoveQueen i j
                -> ( { model | queens = Set.remove (i,j) model.queens, status = Nothing }, Cmd.none )
            ClearQueens
                -> ( { model | queens = Set.empty, status = Nothing }, Cmd.none )

[6.223220]

[4.43618]

            RemoveQueen i j -> 
                let 
                    newModel = 
                        { model 
                            | fixedQueens = if Set.member (i, j) model.solutionQueens
                                then Set.insert (i, j) model.fixedQueens
                                else Set.remove (i,j) model.fixedQueens
                            , solutionQueens = Set.remove (i,j) model.solutionQueens
                            , status = Nothing 
                        }
                in
                    ( newModel, requestSolution newModel )

Replacement in frontend/src/Queens.elm at line 104 [3.108667]

B:BD[4.43619] → [2.2622:2881]

            ChangeBoardSize size
                -> (
                { model 
                    | size = size
                    , queens = Set.filter (\(x,y) -> x < size && y < size) model.queens 
                    , status = Nothing
                }

[4.43619]

[2.2881]

            ClearQueens -> 
                ( { model 
                    | fixedQueens = Set.empty
                    , solutionQueens = Set.empty
                    , status = Nothing 
                  }

Replacement in frontend/src/Queens.elm at line 113 [3.108667]

B:BD[4.43898] → [2.2909:3131]

            Solve
                ->
                    ( model
                    , Http.get 
                        { url = solveUrl
                        , expect = Http.expectJson ReceivedSolution solutionDecoder

[4.43898]

[2.3131]

            ChangeBoardSize size -> 
                let 
                    newModel = 
                        { model 
                            | size = size
                            , fixedQueens = Set.filter (\(x,y) -> x < size && y < size) model.fixedQueens 
                            , status = Nothing

Replacement in frontend/src/Queens.elm at line 121 [3.108667]

B:BD[2.3157] → [2.3157:3179]

[2.3157]

[2.3179]

                in
                    ( newModel, if Set.size newModel.fixedQueens > 0 then requestSolution newModel else Cmd.none)
            Solve ->
                ( model, requestSolution model )

Replacement in frontend/src/Queens.elm at line 129 [3.108667]

B:BD[2.3254] → [2.3254:3476]

                    Ok(sol) ->  ( { model | status = Just Solved, queens = Set.fromList <| List.map (\l -> listToTuple l) sol}, Cmd.none )
                    Err(err) -> ( { model | status = Just Unsolvable }, Cmd.none )

[2.3254]

[4.44125]


                    Ok(sol) ->
                        ( { model 
                            | status = Just Solved
                            , solutionQueens = Set.fromList 
                                <| List.filter (\x -> not (Set.member x model.fixedQueens)) 
                                <| List.map (\l -> listToTuple l) sol
                          }
                        , Cmd.none
                        )

Insertion in frontend/src/Queens.elm at line 140 [3.108667]

[4.44126]

[2.3477]

                    Err(err) -> ( { model | status = Just Unsolvable, solutionQueens = Set.empty}, Cmd.none )

Replacement in frontend/src/Queens.elm at line 211 [3.108667]

B:BD[4.45138] → [2.3880:3997]

                , row [spacing 10, Element.width fill] [ status, sizeSlider, b "Clear" ClearQueens, b "Solve" Solve]

[4.45138]

[4.45238]

                , row [spacing 10, Element.width fill] [ status, sizeSlider, b "Clear" ClearQueens]

Replacement in frontend/src/Queens.elm at line 232 [3.108667]

B:BD[5.18392] → [5.18392:18433]

B:BD[5.18433] → [4.45620:45805]

∅:D[4.45805] → [5.18592:18692]

B:BD[5.18592] → [5.18592:18692]

B:BD[5.18692] → [4.45806:45879]

∅:D[6.224086] → [5.18755:18800]

∅:D[4.45879] → [5.18755:18800]

B:BD[5.18755] → [5.18755:18800]

        queen (i, j) = Svg.foreignObject
            [ Attr.width <| String.fromInt w
            , Attr.height <| String.fromInt w
            , Attr.x <| String.fromInt (i * w)
            , Attr.y <| String.fromInt (j * w)
            , Events.onClick (RemoveQueen i j)
            ]
            <| 
                [ img 
                    [ HAttr.width w
                    , HAttr.height w
                    , src "static/queen.svg"

[5.18392]

[5.18800]

        queen color (i, j) = Svg.g
            []
            [ Svg.foreignObject
                [ Attr.width <| String.fromInt w
                , Attr.height <| String.fromInt w
                , Attr.x <| String.fromInt (i * w)
                , Attr.y <| String.fromInt (j * w)
                ]
                ( 
                    [ img 
                        [ HAttr.width w
                        , HAttr.height w
                        , src "static/queen.svg"
                        ]
                        []
                    ]
                )
                , Svg.rect
                    [ Attr.x <| String.fromInt (i * w)
                    , Attr.y <| String.fromInt (j * w)
                    , Attr.width <| String.fromInt w
                    , Attr.height <| String.fromInt w
                    , Attr.fillOpacity "0.0"
                    , Attr.stroke color
                    , Events.onClick (RemoveQueen i j)

Replacement in frontend/src/Queens.elm at line 259 [3.108667]
B:BD[5.18845] → [5.18845:18863]
```
                ]
```
[5.18845]
[5.18863]
```
            ]
```

Replacement in frontend/src/Queens.elm at line 301 [3.108667]

B:BD[7.5006] → [4.46380:46476]

            <| List.map square squares ++ border ++ (List.map queen <| Set.toList model.queens)

[7.5006]

[5.19886]

            <| 
                List.map square squares 
                ++ border 
                ++ (List.map (queen "red") <| Set.toList model.fixedQueens)
                ++ (List.map (queen "none") <| Set.toList model.solutionQueens)