-module(vec@vec3).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/vec/vec3.gleam").
-export([splat/1, from_tuple/1, to_tuple/1, to_list/1, x/1, y/1, z/1, replace_x/2, replace_y/2, replace_z/2, map_x/2, map_y/2, map_z/2, swap_xy/1, swap_xz/1, swap_yz/1, map/2, map2/3, map3/4, result/1]).
-export_type([vec3/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 vec3(GZE) :: {vec3, GZE, GZE, GZE}.

-file("src/vec/vec3.gleam", 16).
?DOC(
    " Creates a vector with all elements set to a value.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert splat(12) == Vec3(12, 12, 12)\n"
    " ```\n"
).
-spec splat(GZG) -> vec3(GZG).
splat(Value) ->
    {vec3, Value, Value, Value}.

-file("src/vec/vec3.gleam", 28).
?DOC(
    " Converts a tuple of the contained elements into a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert #(12, -34, 420) |> from_tuple == Vec3(12, -34, 420)\n"
    " ```\n"
).
-spec from_tuple({GZI, GZI, GZI}) -> vec3(GZI).
from_tuple(Tuple) ->
    {vec3,
        erlang:element(1, Tuple),
        erlang:element(2, Tuple),
        erlang:element(3, Tuple)}.

-file("src/vec/vec3.gleam", 40).
?DOC(
    " Converts the vector into a tuple of the contained elements.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> to_tuple == #(12, -34, 420)\n"
    " ```\n"
).
-spec to_tuple(vec3(GZK)) -> {GZK, GZK, GZK}.
to_tuple(Vector) ->
    {erlang:element(2, Vector),
        erlang:element(3, Vector),
        erlang:element(4, Vector)}.

-file("src/vec/vec3.gleam", 52).
?DOC(
    " Converts the vector into a list of the contained elements.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> to_list == [12, -34, 420]\n"
    " ```\n"
).
-spec to_list(vec3(GZM)) -> list(GZM).
to_list(Vector) ->
    [erlang:element(2, Vector),
        erlang:element(3, Vector),
        erlang:element(4, Vector)].

-file("src/vec/vec3.gleam", 64).
?DOC(
    " Returns the x element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> x == 12\n"
    " ```\n"
).
-spec x(vec3(GZP)) -> GZP.
x(Vector) ->
    erlang:element(2, Vector).

-file("src/vec/vec3.gleam", 76).
?DOC(
    " Returns the y element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> y == -34\n"
    " ```\n"
).
-spec y(vec3(GZR)) -> GZR.
y(Vector) ->
    erlang:element(3, Vector).

-file("src/vec/vec3.gleam", 88).
?DOC(
    " Returns the z element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> z == 420\n"
    " ```\n"
).
-spec z(vec3(GZT)) -> GZT.
z(Vector) ->
    erlang:element(4, Vector).

-file("src/vec/vec3.gleam", 101).
?DOC(
    " Returns a new vector with the x element replace with `value`.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> replace_x(777) == Vec3(777, -34, 420)\n"
    " ```\n"
).
-spec replace_x(vec3(GZV), GZV) -> vec3(GZV).
replace_x(Vector, Value) ->
    {vec3, Value, erlang:element(3, Vector), erlang:element(4, Vector)}.

-file("src/vec/vec3.gleam", 114).
?DOC(
    " Returns a new vector with the y element replace with `value`.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> replace_y(777) == Vec3(12, 777, 420)\n"
    " ```\n"
).
-spec replace_y(vec3(GZY), GZY) -> vec3(GZY).
replace_y(Vector, Value) ->
    {vec3, erlang:element(2, Vector), Value, erlang:element(4, Vector)}.

-file("src/vec/vec3.gleam", 127).
?DOC(
    " Returns a new vector with the z element replace with `value`.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> replace_z(777) == Vec3(12, -34, 777)\n"
    " ```\n"
).
-spec replace_z(vec3(HAB), HAB) -> vec3(HAB).
replace_z(Vector, Value) ->
    {vec3, erlang:element(2, Vector), erlang:element(3, Vector), Value}.

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

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

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

-file("src/vec/vec3.gleam", 175).
?DOC(
    " Returns a new vector with the x and y elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> swap_xy == Vec3(-34, 12, 420)\n"
    " ```\n"
).
-spec swap_xy(vec3(HAN)) -> vec3(HAN).
swap_xy(Vector) ->
    {vec3,
        erlang:element(3, Vector),
        erlang:element(2, Vector),
        erlang:element(4, Vector)}.

-file("src/vec/vec3.gleam", 187).
?DOC(
    " Returns a new vector with the x and z elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> swap_xz == Vec3(420, -34, 12)\n"
    " ```\n"
).
-spec swap_xz(vec3(HAQ)) -> vec3(HAQ).
swap_xz(Vector) ->
    {vec3,
        erlang:element(4, Vector),
        erlang:element(3, Vector),
        erlang:element(2, Vector)}.

-file("src/vec/vec3.gleam", 199).
?DOC(
    " Returns a new vector with the y and z elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(12, -34, 420) |> swap_yz == Vec3(12, 420, -34)\n"
    " ```\n"
).
-spec swap_yz(vec3(HAT)) -> vec3(HAT).
swap_yz(Vector) ->
    {vec3,
        erlang:element(2, Vector),
        erlang:element(4, Vector),
        erlang:element(3, Vector)}.

-file("src/vec/vec3.gleam", 212).
?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"
    " assert Vec3(12, -34, 420) |> map(fn(x) { x * 2 }) == Vec3(24, -68, 840)\n"
    " ```\n"
).
-spec map(vec3(HAW), fun((HAW) -> HAY)) -> vec3(HAY).
map(Vector, Fun) ->
    {vec3,
        Fun(erlang:element(2, Vector)),
        Fun(erlang:element(3, Vector)),
        Fun(erlang:element(4, Vector))}.

-file("src/vec/vec3.gleam", 227).
?DOC(
    " Combines two vectors into a single vector using the given function.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec3(12, -34, 420)\n"
    "   |> map2(Vec3(1, 2, 3), fn(x, y) { x * y })\n"
    "   == Vec3(12, -68, 1260)\n"
    " ```\n"
).
-spec map2(vec3(HBA), vec3(HBC), fun((HBA, HBC) -> HBE)) -> vec3(HBE).
map2(A, B, Fun) ->
    {vec3,
        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))}.

-file("src/vec/vec3.gleam", 250).
?DOC(
    " Combines three vectors into a single vector using the given function.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " fn linear_interpolation(weight: Float, a: Float, b: Float) -> Float {\n"
    "   a +. { b -. a } *. weight\n"
    " }\n"
    "\n"
    " assert\n"
    "   splat(0.6)\n"
    "   |> map3(\n"
    "     Vec3(1.2, -3.4, 42.0),\n"
    "     Vec3(1.0, 2.1, -5.4),\n"
    "     linear_interpolation,\n"
    "   )\n"
    "   == Vec3(1.08, -0.1, 13.56)\n"
    " ```\n"
).
-spec map3(vec3(HBG), vec3(HBI), vec3(HBK), fun((HBG, HBI, HBK) -> HBK)) -> vec3(HBK).
map3(A, B, C, Fun) ->
    {vec3,
        Fun(erlang:element(2, A), erlang:element(2, B), erlang:element(2, C)),
        Fun(erlang:element(3, A), erlang:element(3, B), erlang:element(3, C)),
        Fun(erlang:element(4, A), erlang:element(4, B), erlang:element(4, C))}.

-file("src/vec/vec3.gleam", 273).
?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"
    " assert Vec3(Ok(12), Ok(-34), Ok(420)) |> result == Ok(Vec3(12, -34, 420))\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " assert Vec3(Ok(12), Error(\"foo\"), Error(\"bar\")) |> result == Error(\"foo\")\n"
    " ```\n"
).
-spec result(vec3({ok, HBN} | {error, HBO})) -> {ok, vec3(HBN)} | {error, HBO}.
result(Vector) ->
    case Vector of
        {vec3, {ok, X}, {ok, Y}, {ok, Z}} ->
            {ok, {vec3, X, Y, Z}};

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

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

        {vec3, _, _, {error, Error@2}} ->
            {error, Error@2}
    end.