vec

-module(vec@vec4).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/vec/vec4.gleam").
-export([splat/1, to_list/1, x/1, y/1, z/1, w/1, replace_x/2, replace_y/2, replace_z/2, replace_w/2, map_x/2, map_y/2, map_z/2, map_w/2, swap_xy/1, swap_xz/1, swap_xw/1, swap_yz/1, swap_yw/1, swap_zw/1, map/2, map2/3, result/1, decoder/1]).
-export_type([vec4/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type vec4(HWP) :: {vec4, HWP, HWP, HWP, HWP}.

-file("src/vec/vec4.gleam", 18).
?DOC(
    " Creates a vector with all elements set to a value.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " splat(12)\n"
    " // -> Vec4(12, 12, 12, 12)\n"
    " ```\n"
).
-spec splat(HWR) -> vec4(HWR).
splat(Value) ->
    {vec4, Value, Value, Value, Value}.

-file("src/vec/vec4.gleam", 31).
?DOC(
    " Converts the set into a list of the contained elements.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> to_list()\n"
    " // -> [12, -34, 420, 69]\n"
    " ```\n"
).
-spec to_list(vec4(HWT)) -> list(HWT).
to_list(Vector) ->
    [erlang:element(2, Vector),
        erlang:element(3, Vector),
        erlang:element(4, Vector),
        erlang:element(5, Vector)].

-file("src/vec/vec4.gleam", 44).
?DOC(
    " Returns the x element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> x()\n"
    " // -> 12\n"
    " ```\n"
).
-spec x(vec4(HWW)) -> HWW.
x(Vector) ->
    erlang:element(2, Vector).

-file("src/vec/vec4.gleam", 57).
?DOC(
    " Returns the y element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> y()\n"
    " // -> -34\n"
    " ```\n"
).
-spec y(vec4(HWY)) -> HWY.
y(Vector) ->
    erlang:element(3, Vector).

-file("src/vec/vec4.gleam", 70).
?DOC(
    " Returns the z element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> z()\n"
    " // -> 420\n"
    " ```\n"
).
-spec z(vec4(HXA)) -> HXA.
z(Vector) ->
    erlang:element(4, Vector).

-file("src/vec/vec4.gleam", 83).
?DOC(
    " Returns the w element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> w()\n"
    " // -> 69\n"
    " ```\n"
).
-spec w(vec4(HXC)) -> HXC.
w(Vector) ->
    erlang:element(5, Vector).

-file("src/vec/vec4.gleam", 96).
?DOC(
    " Returns a new vector with the x element replace with `value`.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> replace_x(777)\n"
    " // -> Vec4(777, -34, 420, 69)\n"
    " ```\n"
).
-spec replace_x(vec4(HXE), HXE) -> vec4(HXE).
replace_x(Vector, Value) ->
    _record = Vector,
    {vec4,
        Value,
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 109).
?DOC(
    " Returns a new vector with the y element replace with `value`.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> replace_y(777)\n"
    " // -> Vec4(12, 777, 420, 69)\n"
    " ```\n"
).
-spec replace_y(vec4(HXH), HXH) -> vec4(HXH).
replace_y(Vector, Value) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        Value,
        erlang:element(4, _record),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 122).
?DOC(
    " Returns a new vector with the z element replace with `value`.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> replace_z(777)\n"
    " // -> Vec4(12, -34, 777, 69)\n"
    " ```\n"
).
-spec replace_z(vec4(HXK), HXK) -> vec4(HXK).
replace_z(Vector, Value) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        erlang:element(3, _record),
        Value,
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 135).
?DOC(
    " Returns a new vector with the w element replace with `value`.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> replace_w(777)\n"
    " // -> Vec4(12, -34, 420, 777)\n"
    " ```\n"
).
-spec replace_w(vec4(HXN), HXN) -> vec4(HXN).
replace_w(Vector, Value) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        Value}.

-file("src/vec/vec4.gleam", 148).
?DOC(
    " Returns a new vector with the x element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> map_x(fn(n) { n * 2 })\n"
    " // -> Vec4(24, -34, 420, 69)\n"
    " ```\n"
).
-spec map_x(vec4(HXQ), fun((HXQ) -> HXQ)) -> vec4(HXQ).
map_x(Vector, Fun) ->
    _record = Vector,
    {vec4,
        Fun(erlang:element(2, Vector)),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 161).
?DOC(
    " Returns a new vector with the y element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> map_y(fn(n) { n * 2 })\n"
    " // -> Vec4(12, -68, 420, 69)\n"
    " ```\n"
).
-spec map_y(vec4(HXT), fun((HXT) -> HXT)) -> vec4(HXT).
map_y(Vector, Fun) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        Fun(erlang:element(3, Vector)),
        erlang:element(4, _record),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 174).
?DOC(
    " Returns a new vector with the z element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> map_z(fn(n) { n * 2 })\n"
    " // -> Vec4(12, -34, 840, 69)\n"
    " ```\n"
).
-spec map_z(vec4(HXW), fun((HXW) -> HXW)) -> vec4(HXW).
map_z(Vector, Fun) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        erlang:element(3, _record),
        Fun(erlang:element(4, Vector)),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 187).
?DOC(
    " Returns a new vector with the w element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> map_w(fn(n) { n * 2 })\n"
    " // -> Vec4(12, -34, 420, 138)\n"
    " ```\n"
).
-spec map_w(vec4(HXZ), fun((HXZ) -> HXZ)) -> vec4(HXZ).
map_w(Vector, Fun) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        Fun(erlang:element(5, Vector))}.

-file("src/vec/vec4.gleam", 200).
?DOC(
    " Returns a new vector with the x and y elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> swap_xy()\n"
    " // -> Vec4(-34, 12, 420, 69)\n"
    " ```\n"
).
-spec swap_xy(vec4(HYC)) -> vec4(HYC).
swap_xy(Vector) ->
    _record = Vector,
    {vec4,
        erlang:element(3, Vector),
        erlang:element(2, Vector),
        erlang:element(4, _record),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 213).
?DOC(
    " Returns a new vector with the x and z elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> swap_xz()\n"
    " // -> Vec4(420, -34, 12, 69)\n"
    " ```\n"
).
-spec swap_xz(vec4(HYF)) -> vec4(HYF).
swap_xz(Vector) ->
    _record = Vector,
    {vec4,
        erlang:element(4, Vector),
        erlang:element(3, _record),
        erlang:element(2, Vector),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 226).
?DOC(
    " Returns a new vector with the x and w elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> swap_xw()\n"
    " // -> Vec4(69, -34, 420, 12)\n"
    " ```\n"
).
-spec swap_xw(vec4(HYI)) -> vec4(HYI).
swap_xw(Vector) ->
    _record = Vector,
    {vec4,
        erlang:element(5, Vector),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(2, Vector)}.

-file("src/vec/vec4.gleam", 239).
?DOC(
    " Returns a new vector with the y and z elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> swap_yz()\n"
    " // -> Vec4(12, 420, -34, 69)\n"
    " ```\n"
).
-spec swap_yz(vec4(HYL)) -> vec4(HYL).
swap_yz(Vector) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        erlang:element(4, Vector),
        erlang:element(3, Vector),
        erlang:element(5, _record)}.

-file("src/vec/vec4.gleam", 252).
?DOC(
    " Returns a new vector with the y and w elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> swap_yw()\n"
    " // -> Vec4(12, 69, 420, -34)\n"
    " ```\n"
).
-spec swap_yw(vec4(HYO)) -> vec4(HYO).
swap_yw(Vector) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        erlang:element(5, Vector),
        erlang:element(4, _record),
        erlang:element(3, Vector)}.

-file("src/vec/vec4.gleam", 265).
?DOC(
    " Returns a new vector with the z and w elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> swap_zw()\n"
    " // -> Vec4(12, -34, 69, 420)\n"
    " ```\n"
).
-spec swap_zw(vec4(HYR)) -> vec4(HYR).
swap_zw(Vector) ->
    _record = Vector,
    {vec4,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(5, Vector),
        erlang:element(4, Vector)}.

-file("src/vec/vec4.gleam", 279).
?DOC(
    " Returns a new vector containing only the elements of the first vector after\n"
    " the function has been applied to each one.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> map(fn(x) { x * 2 })\n"
    " // -> Vec4(24, -68, 840, 138)\n"
    " ```\n"
).
-spec map(vec4(HYU), fun((HYU) -> HYW)) -> vec4(HYW).
map(Vector, Fun) ->
    {vec4,
        Fun(erlang:element(2, Vector)),
        Fun(erlang:element(3, Vector)),
        Fun(erlang:element(4, Vector)),
        Fun(erlang:element(5, Vector))}.

-file("src/vec/vec4.gleam", 292).
?DOC(
    " Combines two vectors into a single vector using the given function.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(12, -34, 420, 69) |> map2(Vec4(1, 2, 3, 4), fn(x, y) { x * y })\n"
    " // -> Vec4(12, -68, 1260, 276)\n"
    " ```\n"
).
-spec map2(vec4(HYY), vec4(HZA), fun((HYY, HZA) -> HZC)) -> vec4(HZC).
map2(A, B, Fun) ->
    {vec4,
        Fun(erlang:element(2, A), erlang:element(2, B)),
        Fun(erlang:element(3, A), erlang:element(3, B)),
        Fun(erlang:element(4, A), erlang:element(4, B)),
        Fun(erlang:element(5, A), erlang:element(5, B))}.

-file("src/vec/vec4.gleam", 312).
?DOC(
    " Combines a vector of results into a single result. If all elements in the\n"
    " vector are `Ok` then returns an `Ok` holding the vector of values. If any\n"
    " element is `Error` then returns the first error.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " Vec4(Ok(12), Ok(-34), Ok(420), Ok(69)) |> result()\n"
    " // -> Ok(Vec4(12, -34, 420, 69))\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " Vec4(Ok(12), Error(\"foo\"), Ok(420), Error(\"bar\")) |> result()\n"
    " // -> Error(\"foo\")\n"
    " ```\n"
).
-spec result(vec4({ok, HZE} | {error, HZF})) -> {ok, vec4(HZE)} | {error, HZF}.
result(Vector) ->
    case Vector of
        {vec4, {ok, X}, {ok, Y}, {ok, Z}, {ok, W}} ->
            {ok, {vec4, X, Y, Z, W}};

        {vec4, {error, Error}, _, _, _} ->
            {error, Error};

        {vec4, _, {error, Error@1}, _, _} ->
            {error, Error@1};

        {vec4, _, _, {error, Error@2}, _} ->
            {error, Error@2};

        {vec4, _, _, _, {error, Error@3}} ->
            {error, Error@3}
    end.

-file("src/vec/vec4.gleam", 324).
?DOC(
    " A decoder that decodes 4D vectors where all elements are decoded with a\n"
    " given decoder.\n"
).
-spec decoder(gleam@dynamic@decode:decoder(HZM)) -> gleam@dynamic@decode:decoder(vec4(HZM)).
decoder(Inner) ->
    gleam@dynamic@decode:field(
        <<"x"/utf8>>,
        Inner,
        fun(X) ->
            gleam@dynamic@decode:field(
                <<"y"/utf8>>,
                Inner,
                fun(Y) ->
                    gleam@dynamic@decode:field(
                        <<"z"/utf8>>,
                        Inner,
                        fun(Z) ->
                            gleam@dynamic@decode:field(
                                <<"w"/utf8>>,
                                Inner,
                                fun(W) ->
                                    gleam@dynamic@decode:success(
                                        {vec4, X, Y, Z, W}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).