vec

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

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

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

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

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

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

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

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

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

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

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

-file("src/vec/vec2.gleam", 138).
?DOC(
    " Returns a new vector with the x and y elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec2(12, -34) |> swap == Vec2(-34, 12)\n"
    " ```\n"
).
-spec swap(vec2(GMI)) -> vec2(GMI).
swap(Vector) ->
    {vec2, erlang:element(3, Vector), erlang:element(2, Vector)}.

-file("src/vec/vec2.gleam", 151).
?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 Vec2(12, -34) |> map(fn(x) { x * 2 }) == Vec2(24, -68)\n"
    " ```\n"
).
-spec map(vec2(GML), fun((GML) -> GMN)) -> vec2(GMN).
map(Vector, Fun) ->
    {vec2, Fun(erlang:element(2, Vector)), Fun(erlang:element(3, Vector))}.

-file("src/vec/vec2.gleam", 165).
?DOC(
    " Combines two vectors into a single vector using the given function.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   map2(Vec2(12, -34), Vec2(420, 69), fn(x, y) { x + y })\n"
    "   == Vec2(432, 35)\n"
    " ```\n"
).
-spec map2(vec2(GMP), vec2(GMR), fun((GMP, GMR) -> GMT)) -> vec2(GMT).
map2(A, B, Fun) ->
    {vec2,
        Fun(erlang:element(2, A), erlang:element(2, B)),
        Fun(erlang:element(3, A), erlang:element(3, B))}.

-file("src/vec/vec2.gleam", 184).
?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(Vec2(1.2, -3.4), Vec2(1.0, 2.1), linear_interpolation)\n"
    "   == Vec2(1.08, -0.1)\n"
    " ```\n"
).
-spec map3(vec2(GMV), vec2(GMX), vec2(GMZ), fun((GMV, GMX, GMZ) -> GMZ)) -> vec2(GMZ).
map3(A, B, C, Fun) ->
    {vec2,
        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))}.

-file("src/vec/vec2.gleam", 207).
?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 Vec2(Ok(12), Ok(-34)) |> result == Ok(Vec2(12, -34))\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " assert Vec2(Ok(12), Error(\"foo\")) |> result == Error(\"foo\")\n"
    " ```\n"
).
-spec result(vec2({ok, GNC} | {error, GND})) -> {ok, vec2(GNC)} | {error, GND}.
result(Vector) ->
    case Vector of
        {vec2, {ok, X}, {ok, Y}} ->
            {ok, {vec2, X, Y}};

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

        {vec2, _, {error, Error@1}} ->
            {error, Error@1}
    end.