-module(lightspeed@async).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lightspeed/async.gleam").
-export([new/1, connected/1, assign_async/2, connect/1, disconnect/1, state_label/1, succeed/3, fail/3, cancel/3, state/2, error_to_string/1]).
-export_type([async_state/1, async_error/0, async_entry/1, runtime/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.
?MODULEDOC(" LiveView-style async assign/task compatibility model.\n").
-type async_state(GFS) :: idle |
pending_disconnected |
{loading, integer()} |
{succeeded, GFS} |
{failed, binary()} |
{cancelled, binary()}.
-type async_error() :: {unknown_task, binary()} |
{invalid_transition, binary(), binary(), binary()}.
-type async_entry(GFT) :: {async_entry, binary(), async_state(GFT)}.
-opaque runtime(GFU) :: {runtime, boolean(), integer(), list(async_entry(GFU))}.
-file("src/lightspeed/async.gleam", 32).
?DOC(" Build a runtime.\n").
-spec new(boolean()) -> runtime(any()).
new(Connected) ->
{runtime, Connected, 1, []}.
-file("src/lightspeed/async.gleam", 37).
?DOC(" Connection status.\n").
-spec connected(runtime(any())) -> boolean().
connected(Runtime) ->
erlang:element(2, Runtime).
-file("src/lightspeed/async.gleam", 203).
-spec put_entry(list(async_entry(GIA)), binary(), async_state(GIA)) -> list(async_entry(GIA)).
put_entry(Entries_rev, Key, State) ->
case Entries_rev of
[] ->
[{async_entry, Key, State}];
[Entry | Rest] ->
case erlang:element(2, Entry) =:= Key of
true ->
[{async_entry, erlang:element(2, Entry), State} | Rest];
false ->
[Entry | put_entry(Rest, Key, State)]
end
end.
-file("src/lightspeed/async.gleam", 45).
?DOC(
" Start one async assignment.\n"
"\n"
" - when connected: enters `Loading(ref)`\n"
" - when disconnected: enters `PendingDisconnected`\n"
).
-spec assign_async(runtime(GFZ), binary()) -> {runtime(GFZ), async_state(GFZ)}.
assign_async(Runtime, Key) ->
case erlang:element(2, Runtime) of
true ->
Ref = erlang:element(3, Runtime),
State = {loading, Ref},
Entries_rev = put_entry(erlang:element(4, Runtime), Key, State),
{{runtime, erlang:element(2, Runtime), Ref + 1, Entries_rev}, State};
false ->
State@1 = pending_disconnected,
Entries_rev@1 = put_entry(erlang:element(4, Runtime), Key, State@1),
{{runtime,
erlang:element(2, Runtime),
erlang:element(3, Runtime),
Entries_rev@1},
State@1}
end.
-file("src/lightspeed/async.gleam", 218).
-spec start_pending(list(async_entry(GIG)), integer(), list(async_entry(GIG))) -> {integer(),
list(async_entry(GIG))}.
start_pending(Entries, Next_ref, Entries_rev) ->
case Entries of
[] ->
{Next_ref, Entries_rev};
[Entry | Rest] ->
case erlang:element(3, Entry) of
pending_disconnected ->
start_pending(
Rest,
Next_ref + 1,
[{async_entry,
erlang:element(2, Entry),
{loading, Next_ref}} |
Entries_rev]
);
_ ->
start_pending(Rest, Next_ref, [Entry | Entries_rev])
end
end.
-file("src/lightspeed/async.gleam", 66).
?DOC(" Mark runtime connected and start pending async assignments.\n").
-spec connect(runtime(GGD)) -> runtime(GGD).
connect(Runtime) ->
{Next_ref, Entries_rev} = start_pending(
lists:reverse(erlang:element(4, Runtime)),
erlang:element(3, Runtime),
[]
),
{runtime, true, Next_ref, Entries_rev}.
-file("src/lightspeed/async.gleam", 74).
?DOC(" Mark runtime disconnected.\n").
-spec disconnect(runtime(GGG)) -> runtime(GGG).
disconnect(Runtime) ->
{runtime, false, erlang:element(3, Runtime), erlang:element(4, Runtime)}.
-file("src/lightspeed/async.gleam", 145).
?DOC(" Stable state label for logs and assertions.\n").
-spec state_label(async_state(any())) -> binary().
state_label(State) ->
case State of
idle ->
<<"idle"/utf8>>;
pending_disconnected ->
<<"pending_disconnected"/utf8>>;
{loading, _} ->
<<"loading"/utf8>>;
{succeeded, _} ->
<<"succeeded"/utf8>>;
{failed, _} ->
<<"failed"/utf8>>;
{cancelled, _} ->
<<"cancelled"/utf8>>
end.
-file("src/lightspeed/async.gleam", 253).
-spec reverse_into(list(GIS), list(GIS)) -> list(GIS).
reverse_into(Left, Right) ->
case Left of
[] ->
Right;
[Entry | Rest] ->
reverse_into(Rest, [Entry | Right])
end.
-file("src/lightspeed/async.gleam", 177).
-spec update_state(
list(async_entry(GHN)),
binary(),
fun((async_state(GHN)) -> {ok, async_state(GHN)} | {error, async_error()}),
list(async_entry(GHN))
) -> {ok, list(async_entry(GHN))} | {error, async_error()}.
update_state(Entries_rev, Key, With, Seen_rev) ->
case Entries_rev of
[] ->
{error, {unknown_task, Key}};
[Entry | Rest] ->
case erlang:element(2, Entry) =:= Key of
false ->
update_state(Rest, Key, With, [Entry | Seen_rev]);
true ->
case With(erlang:element(3, Entry)) of
{error, Error} ->
{error, Error};
{ok, State} ->
{ok,
reverse_into(
Seen_rev,
[{async_entry,
erlang:element(2, Entry),
State} |
Rest]
)}
end
end
end.
-file("src/lightspeed/async.gleam", 165).
-spec transition(
runtime(GHE),
binary(),
binary(),
fun((async_state(GHE)) -> {ok, async_state(GHE)} | {error, async_error()})
) -> {runtime(GHE), {ok, nil} | {error, async_error()}}.
transition(Runtime, Key, _, With) ->
case update_state(erlang:element(4, Runtime), Key, With, []) of
{error, Error} ->
{Runtime, {error, Error}};
{ok, Entries_rev} ->
{{runtime,
erlang:element(2, Runtime),
erlang:element(3, Runtime),
Entries_rev},
{ok, nil}}
end.
-file("src/lightspeed/async.gleam", 79).
?DOC(" Resolve one async assignment with a success value.\n").
-spec succeed(runtime(GGJ), binary(), GGJ) -> {runtime(GGJ),
{ok, nil} | {error, async_error()}}.
succeed(Runtime, Key, Value) ->
transition(Runtime, Key, <<"succeed"/utf8>>, fun(State) -> case State of
{loading, _} ->
{ok, {succeeded, Value}};
_ ->
{error,
{invalid_transition,
Key,
state_label(State),
<<"succeed"/utf8>>}}
end end).
-file("src/lightspeed/async.gleam", 98).
?DOC(" Resolve one async assignment with a failure.\n").
-spec fail(runtime(GGO), binary(), binary()) -> {runtime(GGO),
{ok, nil} | {error, async_error()}}.
fail(Runtime, Key, Reason) ->
transition(Runtime, Key, <<"fail"/utf8>>, fun(State) -> case State of
{loading, _} ->
{ok, {failed, Reason}};
_ ->
{error,
{invalid_transition,
Key,
state_label(State),
<<"fail"/utf8>>}}
end end).
-file("src/lightspeed/async.gleam", 117).
?DOC(" Cancel one async assignment.\n").
-spec cancel(runtime(GGT), binary(), binary()) -> {runtime(GGT),
{ok, nil} | {error, async_error()}}.
cancel(Runtime, Key, Reason) ->
transition(Runtime, Key, <<"cancel"/utf8>>, fun(State) -> case State of
pending_disconnected ->
{ok, {cancelled, Reason}};
{loading, _} ->
{ok, {cancelled, Reason}};
_ ->
{error,
{invalid_transition,
Key,
state_label(State),
<<"cancel"/utf8>>}}
end end).
-file("src/lightspeed/async.gleam", 239).
-spec find_state(list(async_entry(GIN)), binary()) -> gleam@option:option(async_state(GIN)).
find_state(Entries_rev, Key) ->
case Entries_rev of
[] ->
none;
[Entry | Rest] ->
case erlang:element(2, Entry) =:= Key of
true ->
{some, erlang:element(3, Entry)};
false ->
find_state(Rest, Key)
end
end.
-file("src/lightspeed/async.gleam", 137).
?DOC(" Lookup current state for one task key.\n").
-spec state(runtime(GGY), binary()) -> gleam@option:option(async_state(GGY)).
state(Runtime, Key) ->
find_state(erlang:element(4, Runtime), Key).
-file("src/lightspeed/async.gleam", 157).
?DOC(" Stable error string for assertions and logs.\n").
-spec error_to_string(async_error()) -> binary().
error_to_string(Error) ->
case Error of
{unknown_task, Key} ->
<<"unknown_task:"/utf8, Key/binary>>;
{invalid_transition, Key@1, State, Action} ->
<<<<<<<<<<"invalid_transition:"/utf8, Key@1/binary>>/binary,
":"/utf8>>/binary,
State/binary>>/binary,
":"/utf8>>/binary,
Action/binary>>
end.
