Current section
Files
Jump to
Current section
Files
src/stream.erl
-module(stream).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/stream.gleam").
-export([has_next/1, next/1, generate_until/3, each/2, generate/2, map/2, from_list/1, empty/0, copy/1, fold/3, to_list/1, until/2, filter/2, drop_while/2, drop/2, flatten/1, flat_map/2]).
-export_type([message/1, state/1, stream/1]).
-type message(FLT) :: {get_next,
gleam@erlang@process:subject(gleam@option:option(FLT))} |
{has_next, gleam@erlang@process:subject(boolean())}.
-type state(FLU) :: finished |
{un_initialized, fun(() -> FLU)} |
{generating, FLU}.
-opaque stream(FLV) :: {true_generator,
gleam@erlang@process:subject(message(FLV)),
gleam@erlang@process:pid_(),
fun((state(FLV), message(FLV)) -> gleam@otp@actor:next(state(FLV), message(FLV))),
fun(() -> FLV)} |
empty_generator.
-file("src/stream.gleam", 29).
-spec save_call(
gleam@erlang@process:subject(message(FLW)),
fun((gleam@erlang@process:subject(FLZ)) -> message(FLW))
) -> {ok, FLZ} | {error, nil}.
save_call(Subject, Message) ->
Reply_to = gleam@erlang@process:new_subject(),
gleam@erlang@process:send(Subject, Message(Reply_to)),
gleam@erlang@process:'receive'(Reply_to, 1000).
-file("src/stream.gleam", 38).
-spec try_if_alive(
stream(FMD),
FMF,
fun((gleam@erlang@process:subject(message(FMD)), gleam@erlang@process:pid_()) -> {ok,
FMF} |
{error, nil})
) -> FMF.
try_if_alive(Generator, Fallback, If_alive) ->
case Generator of
empty_generator ->
Fallback;
{true_generator, _, Pid, _, _} ->
gleam@bool:guard(
begin
_pipe = erlang:is_process_alive(Pid),
gleam@bool:negate(_pipe)
end,
Fallback,
fun() ->
_pipe@1 = If_alive(
erlang:element(2, Generator),
erlang:element(3, Generator)
),
gleam@result:unwrap(_pipe@1, Fallback)
end
)
end.
-file("src/stream.gleam", 52).
-spec has_next(stream(any())) -> boolean().
has_next(Generator) ->
try_if_alive(
Generator,
false,
fun(Subject, _) ->
save_call(Subject, fun(Field@0) -> {has_next, Field@0} end)
end
).
-file("src/stream.gleam", 57).
-spec next(stream(FMM)) -> gleam@option:option(FMM).
next(Generator) ->
try_if_alive(
Generator,
none,
fun(Subject, _) ->
save_call(Subject, fun(Field@0) -> {get_next, Field@0} end)
end
).
-file("src/stream.gleam", 62).
-spec handle_message(
fun((FMP) -> FMP),
fun((FMP) -> boolean()),
state(FMP),
message(FMP)
) -> gleam@otp@actor:next(state(FMP), any()).
handle_message(Generator, Until, State, Message) ->
New_state = case {State, Message} of
{finished, {get_next, Return_to}} ->
gleam@erlang@process:send(Return_to, none),
finished;
{{generating, Cur}, {get_next, Return_to@1}} ->
Next = Generator(Cur),
gleam@erlang@process:send(Return_to@1, {some, Next}),
case Until(Next) of
true ->
finished;
false ->
{generating, Next}
end;
{{un_initialized, Init}, {get_next, Return_to@2}} ->
First = Init(),
gleam@erlang@process:send(Return_to@2, {some, First}),
case Until(First) of
true ->
finished;
false ->
{generating, First}
end;
{finished, {has_next, Return_to@3}} ->
gleam@erlang@process:send(Return_to@3, false),
finished;
{{un_initialized, X}, {has_next, Return_to@4}} ->
gleam@erlang@process:send(Return_to@4, true),
{un_initialized, X};
{{generating, X@1}, {has_next, Return_to@5}} ->
gleam@erlang@process:send(Return_to@5, true),
{generating, X@1}
end,
case New_state of
finished ->
gleam@otp@actor:stop();
_ ->
gleam@otp@actor:continue(New_state)
end.
-file("src/stream.gleam", 110).
-spec create(
fun(() -> FMT),
fun((state(FMT), message(FMT)) -> gleam@otp@actor:next(state(FMT), message(FMT)))
) -> stream(FMT).
create(Seed, Handle) ->
My_actor@1 = case begin
_pipe = gleam@otp@actor:new({un_initialized, Seed}),
_pipe@1 = gleam@otp@actor:on_message(_pipe, Handle),
gleam@otp@actor:start(_pipe@1)
end of
{ok, My_actor} -> My_actor;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"create"/utf8>>,
line => 114,
value => _assert_fail,
start => 2655,
'end' => 2766,
pattern_start => 2666,
pattern_end => 2678})
end,
{true_generator,
erlang:element(3, My_actor@1),
erlang:element(2, My_actor@1),
Handle,
Seed}.
-file("src/stream.gleam", 128).
-spec id(FNB) -> fun(() -> FNB).
id(X) ->
fun() -> X end.
-file("src/stream.gleam", 132).
-spec generate_until(fun(() -> FNC), fun((FNC) -> FNC), fun((FNC) -> boolean())) -> stream(FNC).
generate_until(Seed, Generate, Until) ->
create(
Seed,
fun(State, Message) ->
handle_message(Generate, Until, State, Message)
end
).
-file("src/stream.gleam", 141).
-spec each(stream(FNE), fun((FNE) -> nil)) -> nil.
each(From, Do) ->
case next(From) of
none ->
nil;
{some, Val} ->
Do(Val),
each(From, Do)
end.
-file("src/stream.gleam", 153).
-spec generate(fun(() -> FNG), fun((FNG) -> FNG)) -> stream(FNG).
generate(Seed, By) ->
create(
Seed,
fun(State, Message) ->
handle_message(By, fun(_) -> true end, State, Message)
end
).
-file("src/stream.gleam", 183).
-spec assert_some(gleam@option:option(FNL)) -> FNL.
assert_some(Item) ->
Item@2 = case Item of
{some, Item@1} -> Item@1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"assert_some"/utf8>>,
line => 184,
value => _assert_fail,
start => 4043,
'end' => 4071,
pattern_start => 4054,
pattern_end => 4064})
end,
Item@2.
-file("src/stream.gleam", 188).
-spec map(stream(FNN), fun((FNN) -> FNP)) -> stream(FNP).
map(From, By) ->
case has_next(From) of
false ->
empty_generator;
true ->
generate_until(
begin
_pipe = next(From),
_pipe@1 = assert_some(_pipe),
_pipe@2 = By(_pipe@1),
id(_pipe@2)
end,
fun(_) -> _pipe@3 = next(From),
_pipe@4 = assert_some(_pipe@3),
By(_pipe@4) end,
fun(_) -> _pipe@5 = has_next(From),
gleam@bool:negate(_pipe@5) end
)
end.
-file("src/stream.gleam", 158).
-spec from_list(list(FNI)) -> stream(FNI).
from_list(Values) ->
Gen = case Values of
[] ->
empty_generator;
[First | Res] ->
generate_until(
id({Res, First}),
fun(X) ->
{Values@1, _} = X,
{Next@1, Res@2} = case Values@1 of
[Next | Res@1] -> {Next, Res@1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"from_list"/utf8>>,
line => 166,
value => _assert_fail,
start => 3739,
'end' => 3772,
pattern_start => 3750,
pattern_end => 3763})
end,
{Res@2, Next@1}
end,
fun(X@1) ->
{Values@2, _} = X@1,
case Values@2 of
[_ | _] ->
false;
_ ->
true
end
end
)
end,
map(
Gen,
fun(_use0) ->
{_, Cur} = _use0,
Cur
end
).
-file("src/stream.gleam", 201).
-spec empty() -> stream(any()).
empty() ->
empty_generator.
-file("src/stream.gleam", 210).
-spec copy(stream(FNW)) -> stream(FNW).
copy(Original) ->
case Original of
empty_generator ->
empty_generator;
{true_generator, _, _, Handle, Seed} ->
create(Seed, Handle)
end.
-file("src/stream.gleam", 248).
-spec fold(stream(FOF), FOH, fun((FOH, FOF) -> FOH)) -> FOH.
fold(Stream, Initial, Fun) ->
_pipe = Stream,
_pipe@1 = next(_pipe),
_pipe@2 = gleam@option:map(
_pipe@1,
fun(_capture) -> Fun(Initial, _capture) end
),
_pipe@3 = gleam@option:map(
_pipe@2,
fun(_capture@1) -> fold(Stream, _capture@1, Fun) end
),
gleam@option:unwrap(_pipe@3, Initial).
-file("src/stream.gleam", 260).
-spec to_list(stream(FOI)) -> list(FOI).
to_list(From) ->
_pipe = From,
_pipe@1 = fold(_pipe, [], fun gleam@list:prepend/2),
lists:reverse(_pipe@1).
-file("src/stream.gleam", 264).
-spec map_unwrap(gleam@option:option(FOL), fun(() -> FON), fun((FOL) -> FON)) -> FON.
map_unwrap(Option, Or, By) ->
_pipe = Option,
_pipe@1 = gleam@option:map(_pipe, By),
gleam@option:lazy_unwrap(_pipe@1, Or).
-file("src/stream.gleam", 205).
-spec until(stream(FNT), fun((FNT) -> boolean())) -> stream(FNT).
until(From, Until) ->
map_unwrap(
next(From),
id(empty_generator),
fun(First) -> generate_until(id(First), fun(_) -> _pipe = next(From),
assert_some(_pipe) end, Until) end
).
-file("src/stream.gleam", 219).
-spec next_match(stream(FNZ), fun((FNZ) -> boolean())) -> gleam@option:option(FNZ).
next_match(From, Predicate) ->
map_unwrap(next(From), id(none), fun(X) -> case Predicate(X) of
true ->
{some, X};
false ->
next_match(From, Predicate)
end end).
-file("src/stream.gleam", 227).
-spec filter(stream(FOC), fun((FOC) -> boolean())) -> stream(FOC).
filter(From, Predicate) ->
Next_val = fun() -> next_match(From, Predicate) end,
Intermediate = begin
map_unwrap(
Next_val(),
id(empty_generator),
fun(First) ->
generate_until(
fun() -> {First, Next_val()} end,
fun(A) ->
Cur@1 = case A of
{_, {some, Cur}} -> Cur;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"filter"/utf8>>,
line => 234,
value => _assert_fail,
start => 5331,
'end' => 5361,
pattern_start => 5342,
pattern_end => 5357})
end,
{Cur@1, Next_val()}
end,
fun(A@1) ->
{_, Next} = A@1,
gleam@option:is_none(Next)
end
)
end
)
end,
map(
Intermediate,
fun(_use0) ->
{Cur@2, _} = _use0,
Cur@2
end
).
-file("src/stream.gleam", 270).
-spec indexed(stream(FOO)) -> stream({FOO, integer()}).
indexed(Stream) ->
map_unwrap(
next(Stream),
fun empty/0,
fun(First) ->
generate_until(
fun() -> {First, 0} end,
fun(_use0) ->
{_, Last_index} = _use0,
Val@1 = case next(Stream) of
{some, Val} -> Val;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"indexed"/utf8>>,
line => 275,
value => _assert_fail,
start => 6216,
'end' => 6251,
pattern_start => 6227,
pattern_end => 6236})
end,
{Val@1, Last_index + 1}
end,
fun(_) -> _pipe = has_next(Stream),
gleam@bool:negate(_pipe) end
)
end
).
-file("src/stream.gleam", 279).
-spec drop_while(stream(FOR), fun((FOR) -> boolean())) -> stream(FOR).
drop_while(Stream, Predicate) ->
map_unwrap(next_match(Stream, fun(X) -> _pipe = X,
_pipe@1 = Predicate(_pipe),
gleam@bool:negate(_pipe@1) end), fun empty/0, fun(First) ->
generate_until(
id(First),
fun(_) ->
Val@1 = case next(Stream) of
{some, Val} -> Val;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"drop_while"/utf8>>,
line => 290,
value => _assert_fail,
start => 6593,
'end' => 6628,
pattern_start => 6604,
pattern_end => 6613})
end,
Val@1
end,
fun(_) -> _pipe@2 = has_next(Stream),
gleam@bool:negate(_pipe@2) end
)
end).
-file("src/stream.gleam", 294).
-spec drop(stream(FOU), integer()) -> stream(FOU).
drop(Stream, N) ->
Intermediate = begin
drop_while(
indexed(Stream),
fun(_use0) ->
{_, Index} = _use0,
Index < N
end
)
end,
map(
Intermediate,
fun(_use0@1) ->
{Val, _} = _use0@1,
Val
end
).
-file("src/stream.gleam", 310).
-spec flatten(stream(stream(integer()))) -> stream(integer()).
flatten(Streams) ->
Next_stream = fun() -> next_match(Streams, fun has_next/1) end,
map_unwrap(
Next_stream(),
fun empty/0,
fun(First_generator) ->
Intermediate = generate_until(
fun() ->
First_val@1 = case next(First_generator) of
{some, First_val} -> First_val;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"flatten"/utf8>>,
line => 317,
value => _assert_fail,
start => 7218,
'end' => 7268,
pattern_start => 7229,
pattern_end => 7244})
end,
{First_val@1, First_generator, Next_stream()}
end,
fun(X) ->
{_, Cur_stream, Next_maybe} = X,
map_unwrap(
next(Cur_stream),
fun() ->
Cur_stream@2 = case Next_maybe of
{some, Cur_stream@1} -> Cur_stream@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"flatten"/utf8>>,
line => 326,
value => _assert_fail@1,
start => 7509,
'end' => 7549,
pattern_start => 7520,
pattern_end => 7536})
end,
Val@1 = case next(Cur_stream@2) of
{some, Val} -> Val;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"stream"/utf8>>,
function => <<"flatten"/utf8>>,
line => 327,
value => _assert_fail@2,
start => 7558,
'end' => 7597,
pattern_start => 7569,
pattern_end => 7578})
end,
{Val@1, Cur_stream@2, Next_stream()}
end,
fun(Val@2) -> {Val@2, Cur_stream, Next_maybe} end
)
end,
fun(X@1) ->
{_, Cur_stream@3, Next_maybe@1} = X@1,
Has_some = has_next(Cur_stream@3) orelse begin
_pipe = Next_maybe@1,
_pipe@1 = gleam@option:map(_pipe, fun has_next/1),
gleam@option:unwrap(_pipe@1, false)
end,
_pipe@2 = Has_some,
gleam@bool:negate(_pipe@2)
end
),
map(
Intermediate,
fun(_use0) ->
{Val@3, _, _} = _use0,
Val@3
end
)
end
).
-file("src/stream.gleam", 303).
-spec flat_map(stream(integer()), fun((integer()) -> stream(integer()))) -> stream(integer()).
flat_map(Stream, Fun) ->
_pipe = Stream,
_pipe@1 = map(_pipe, Fun),
flatten(_pipe@1).