Current section
Files
Jump to
Current section
Files
src/gleamgen@expression.erl
-module(gleamgen@expression).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamgen/expression.gleam").
-export([type_/1, int/1, float/1, string/1, bool/1, nil/0, to_dynamic/1, list/1, list_prepend/2, equals/2, not_equals/2, field/2, tuple1/1, tuple2/2, tuple3/3, tuple4/4, tuple5/5, tuple6/6, tuple7/7, tuple8/8, tuple9/9, raw/1, raw_doc/1, imported_ident/2, raw_of_type/2, imported_ident_of_type/3, concat_string/2, todo_/1, panic_/1, assert_/2, echo_/2, ok/1, error/1, option_some/1, option_none/0, 'and'/2, 'or'/2, math_operator/3, math_operator_float/3, comparison/3, comparison_float/3, call0/1, call1/2, call2/3, call3/4, call4/5, call5/6, call6/7, call7/8, call8/9, call9/10, call_dynamic/2, construct0/1, new_block/2, update_or_create_block/2, add_to_or_create_block/2, new_use/3, new_case/4, new_anonymous_function/4, with_render_config/2, coerce_dynamic_unsafe/1, render_statement/2, render/2]).
-export_type([expression/1, internal_expression/1, bool_operator/0, math_operator/0, comparison/0, statement/0]).
-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(
" ## Generating Expressions:\n"
" ### Literals:\n"
" - [`int`](#int)\n"
" - [`float`](#float)\n"
" - [`string`](#string)\n"
" - [`bool`](#bool)\n"
" - [`nil`](#nil)\n"
" - [`list`](#list)\n"
" - tuple literals ([`tuple1`](#tuple1), [`tuple2`](#tuple2), [`tuple3`](#tuple3), [`tuple4`](#tuple4), [`tuple5`](#tuple5), [`tuple6`](#tuple6), [`tuple7`](#tuple7), [`tuple8`](#tuple8), [`tuple9`](#tuple9))\n"
" ### Operators:\n"
" - [`comparison`](#comparison)\n"
" - [`comparison_float`](#comparison_float)\n"
" - [`math_operator`](#math_operator)\n"
" - [`math_operator_float`](#math_operator_float)\n"
" - [`equals`](#equals)\n"
" - [`not_equals`](#not_equals)\n"
" - [`list_prepend`](#list_prepend)\n"
" - [`and`](#and)\n"
" - [`or`](#or)\n"
" ### Keywords:\n"
" - [`echo_`](#echo_)\n"
" - [`todo_`](#todo_)\n"
" - [`panic_`](#panic_)\n"
" - [`assert_`](#assert_)\n"
" ### Other expressions:\n"
" - [`ok`](#ok)\n"
" - [`error`](#error)\n"
" - [`option_some`](#option_some)\n"
" - [`option_none`](#option_none)\n"
" - [`function.anonymous`](function.html#anonymous)\n"
" - constructors ([`construct0`](#construct0), [`construct1`](#construct1), [`construct2`](#construct2), [`construct3`](#construct3), [`construct4`](#construct4), [`construct5`](#construct5), [`construct6`](#construct6), [`construct7`](#construct7), [`construct8`](#construct8), [`construct9`](#construct9))\n"
" - call expressions ([`call0`](#call0), [`call1`](#call1), [`call2`](#call2), [`call3`](#call3), [`call4`](#call4), [`call5`](#call5), [`call6`](#call6), [`call7`](#call7), [`call8`](#call8), [`call9`](#call9))\n"
" - import from other files ([`import_.value_of_type`](import_.html#value_of_type), [`import_.raw_ident`](import_.html#raw_ident))\n"
" ### Creating dynamic expressions:\n"
" - [`raw`](#raw)\n"
" - [`raw_of_type`](#raw_of_type)\n"
" - [`call_dynamic`](#call_dynamic)\n"
" - [`to_dynamic`](#to_dynamic)\n"
" - [`coerce_dynamic_unsafe`](#coerce_dynamic_unsafe)\n"
" ## Using expressions:\n"
" - [`render`](#render)\n"
" - [`type_`](#type_)\n"
).
-opaque expression(HOJ) :: {expression,
internal_expression(HOJ),
gleamgen@type_:generated_type(HOJ)}.
-type internal_expression(HOK) :: {int_literal, integer()} |
{float_literal, float()} |
{str_literal, binary()} |
{bool_literal, boolean()} |
nil_literal |
{list_literal,
list(expression(gleamgen@type_:dynamic_())),
gleam@option:option(expression(gleamgen@type_:dynamic_()))} |
{equals,
expression(gleamgen@type_:dynamic_()),
expression(gleamgen@type_:dynamic_())} |
{not_equals,
expression(gleamgen@type_:dynamic_()),
expression(gleamgen@type_:dynamic_())} |
{tuple_literal, list(expression(gleamgen@type_:dynamic_()))} |
{ident, binary()} |
{imported_ident,
gleamgen@internal@import_reference:import_reference(),
binary()} |
{raw_doc, glam@doc:document()} |
{todo, gleam@option:option(binary())} |
{panic, gleam@option:option(binary())} |
{field, expression(gleamgen@type_:dynamic_()), binary()} |
{echo, expression(gleamgen@type_:dynamic_()), gleam@option:option(binary())} |
{assert,
expression(gleamgen@type_:dynamic_()),
gleam@option:option(binary())} |
{math_operator,
expression(gleamgen@type_:dynamic_()),
math_operator(),
expression(gleamgen@type_:dynamic_())} |
{math_operator_float,
expression(gleamgen@type_:dynamic_()),
math_operator(),
expression(gleamgen@type_:dynamic_())} |
{bool_operator,
expression(gleamgen@type_:dynamic_()),
bool_operator(),
expression(gleamgen@type_:dynamic_())} |
{comparison,
expression(gleamgen@type_:dynamic_()),
comparison(),
expression(gleamgen@type_:dynamic_())} |
{comparison_float,
expression(gleamgen@type_:dynamic_()),
comparison(),
expression(gleamgen@type_:dynamic_())} |
{concat_string,
expression(gleamgen@type_:dynamic_()),
expression(gleamgen@type_:dynamic_())} |
{call,
expression(gleamgen@type_:dynamic_()),
list(expression(gleamgen@type_:dynamic_()))} |
{single_constructor, expression(gleamgen@type_:dynamic_())} |
{block, list(statement())} |
{'case',
expression(gleamgen@type_:dynamic_()),
fun((gleamgen@internal@render:context()) -> list(fun((integer()) -> gleamgen@internal@render:rendered()))),
boolean()} |
{anonymous_function,
fun((gleamgen@internal@render:context()) -> gleamgen@internal@render:rendered()),
expression(gleamgen@type_:dynamic_()),
list(gleamgen@parameter:parameter(gleamgen@type_:dynamic_()))} |
{use,
expression(gleamgen@type_:dynamic_()),
list(expression(gleamgen@type_:dynamic_())),
list(binary())} |
{with_config,
expression(gleamgen@type_:dynamic_()),
gleamgen@render@config:config()} |
{gleam_phantom, HOK}.
-type bool_operator() :: 'and' | 'or'.
-type math_operator() :: add | sub | mul | 'div'.
-type comparison() :: greater_than |
greater_than_or_equal |
less_than |
less_than_or_equal.
-type statement() :: {let_declaration,
fun((gleamgen@internal@render:context()) -> gleamgen@internal@render:rendered()),
expression(gleamgen@type_:dynamic_()),
boolean()} |
{expression_statement, expression(gleamgen@type_:dynamic_())} |
{comment, list(binary())} |
linebreak.
-file("src/gleamgen/expression.gleam", 1055).
?DOC(" Get the internal type of an expression\n").
-spec type_(expression(IBV)) -> gleamgen@type_:generated_type(IBV).
type_(Expr) ->
erlang:element(3, Expr).
-file("src/gleamgen/expression.gleam", 140).
?DOC(
" Create an integer literal expression.\n"
"\n"
" ```gleam\n"
" expression.int(42) // Expression(Int) -> 42\n"
" ```\n"
).
-spec int(integer()) -> expression(integer()).
int(Value) ->
{expression, {int_literal, Value}, generated_int}.
-file("src/gleamgen/expression.gleam", 149).
?DOC(
" Create a float literal expression.\n"
"\n"
" ```gleam\n"
" expression.float(3.14) // Expression(Float) -> 3.14\n"
" ```\n"
).
-spec float(float()) -> expression(float()).
float(Value) ->
{expression, {float_literal, Value}, generated_float}.
-file("src/gleamgen/expression.gleam", 158).
?DOC(
" Create a string literal expression.\n"
"\n"
" ```gleam\n"
" expression.string(\"Labas!\") // Expression(String) -> \"Labas!\"\n"
" ```\n"
).
-spec string(binary()) -> expression(binary()).
string(Value) ->
{expression, {str_literal, Value}, generated_string}.
-file("src/gleamgen/expression.gleam", 167).
?DOC(
" Create a boolean literal expression.\n"
"\n"
" ```gleam\n"
" expression.bool(True) // Expression(Bool) -> True\n"
" ```\n"
).
-spec bool(boolean()) -> expression(boolean()).
bool(Value) ->
{expression, {bool_literal, Value}, generated_bool}.
-file("src/gleamgen/expression.gleam", 176).
?DOC(
" Create a Nil literal expression.\n"
"\n"
" ```gleam\n"
" expression.nil() // Expression(Nil) -> Nil\n"
" ```\n"
).
-spec nil() -> expression(nil).
nil() ->
{expression, nil_literal, generated_nil}.
-file("src/gleamgen/expression.gleam", 1078).
-spec to_dynamic(expression(any())) -> expression(gleamgen@type_:dynamic_()).
to_dynamic(Type_) ->
gleamgen_ffi:identity(Type_).
-file("src/gleamgen/expression.gleam", 191).
?DOC(
" Create a list literal expression.\n"
"\n"
" ```gleam\n"
" expression.list([\n"
" expression.int(1),\n"
" expression.int(2),\n"
" expression.int(3),\n"
" expression.int(4),\n"
" ]) // Expression(List(Int)) -> [1, 2, 3, 4]\n"
" ```\n"
" See also [`list_prepend`](#list_prepend).\n"
).
-spec list(list(expression(HOQ))) -> expression(list(HOQ)).
list(Value) ->
{expression,
{list_literal,
begin
_pipe = Value,
gleam@list:map(_pipe, fun gleamgen_ffi:identity/1)
end,
none},
begin
_pipe@1 = Value,
_pipe@2 = gleam@list:first(_pipe@1),
_pipe@3 = gleam@result:map(_pipe@2, fun type_/1),
_pipe@4 = gleam@result:lazy_unwrap(
_pipe@3,
fun() -> gleamgen@type_:dynamic() end
),
gleamgen@type_:list(_pipe@4)
end}.
-file("src/gleamgen/expression.gleam", 210).
?DOC(
" Prepend value(s) to list using `[value, ..original]` syntax.\n"
" \n"
" ```gleam\n"
" expression.list_prepend(\n"
" [expression.int(1), expression.int(2)],\n"
" expression.raw(\"integers\")\n"
" ) Expression(List(Int)) // -> [1, 2, ..integers]\n"
" ```\n"
).
-spec list_prepend(list(expression(HOV)), expression(list(HOV))) -> expression(list(HOV)).
list_prepend(Prepending, Original) ->
{expression,
{list_literal,
begin
_pipe = Prepending,
gleam@list:map(_pipe, fun gleamgen_ffi:identity/1)
end,
{some,
begin
_pipe@1 = Original,
gleamgen_ffi:identity(_pipe@1)
end}},
begin
_pipe@2 = Prepending,
_pipe@3 = gleam@list:first(_pipe@2),
_pipe@4 = gleam@result:map(_pipe@3, fun type_/1),
_pipe@5 = gleam@result:map(_pipe@4, fun gleamgen@type_:list/1),
gleam@result:unwrap(_pipe@5, erlang:element(3, Original))
end}.
-file("src/gleamgen/expression.gleam", 236).
?DOC(
" Determine if values are equal using `==` syntax.\n"
"\n"
" ```gleam\n"
" expression.equals(\n"
" expression.raw(\"movie\"),\n"
" expression.string(\"The Needle\")\n"
" ) // Expression(Bool) -> movie == \"The Needle\"\n"
" ```\n"
" See also: `not_equals`.\n"
).
-spec equals(expression(HPC), expression(HPC)) -> expression(boolean()).
equals(First, Second) ->
{expression,
{equals,
begin
_pipe = First,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Second,
gleamgen_ffi:identity(_pipe@1)
end},
generated_bool}.
-file("src/gleamgen/expression.gleam", 249).
?DOC(
" Determine if values are not equal using `!=` syntax.\n"
"\n"
" ```gleam\n"
" expression.not_equals(\n"
" expression.raw(\"movie\"),\n"
" expression.string(\"The Shining\")\n"
" ) // Expression(Bool) -> movie != \"The Shining\"\n"
" ```\n"
" See also: `equals`.\n"
).
-spec not_equals(expression(HPG), expression(HPG)) -> expression(boolean()).
not_equals(First, Second) ->
{expression,
{not_equals,
begin
_pipe = First,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Second,
gleamgen_ffi:identity(_pipe@1)
end},
generated_bool}.
-file("src/gleamgen/expression.gleam", 266).
?DOC(
" Access a field of a custom type or tuple.\n"
" This function cannot be type checked, so it returns an `Expression(type_.Dynamic)`\n"
"\n"
" ```gleam\n"
" expression.field(expression.raw(\"movie\"), \"director\") \n"
" // Expression(type_.Dynamic) -> movie.director\n"
" ```\n"
).
-spec field(expression(any()), binary()) -> expression(gleamgen@type_:dynamic_()).
field(Base, Field) ->
{expression,
{field, gleamgen_ffi:identity(Base), Field},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 270).
-spec tuple1(expression(HPN)) -> expression({HPN}).
tuple1(Arg1) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end]},
gleamgen@type_:tuple1(type_(Arg1))}.
-file("src/gleamgen/expression.gleam", 277).
-spec tuple2(expression(HPQ), expression(HPS)) -> expression({HPQ, HPS}).
tuple2(Arg1, Arg2) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end]},
gleamgen@type_:tuple2(type_(Arg1), type_(Arg2))}.
-file("src/gleamgen/expression.gleam", 284).
-spec tuple3(expression(HPV), expression(HPX), expression(HPZ)) -> expression({HPV,
HPX,
HPZ}).
tuple3(Arg1, Arg2, Arg3) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg3,
gleamgen_ffi:identity(_pipe@2)
end]},
gleamgen@type_:tuple3(type_(Arg1), type_(Arg2), type_(Arg3))}.
-file("src/gleamgen/expression.gleam", 299).
-spec tuple4(expression(HQC), expression(HQE), expression(HQG), expression(HQI)) -> expression({HQC,
HQE,
HQG,
HQI}).
tuple4(Arg1, Arg2, Arg3, Arg4) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg3,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg4,
gleamgen_ffi:identity(_pipe@3)
end]},
gleamgen@type_:tuple4(
type_(Arg1),
type_(Arg2),
type_(Arg3),
type_(Arg4)
)}.
-file("src/gleamgen/expression.gleam", 316).
-spec tuple5(
expression(HQL),
expression(HQN),
expression(HQP),
expression(HQR),
expression(HQT)
) -> expression({HQL, HQN, HQP, HQR, HQT}).
tuple5(Arg1, Arg2, Arg3, Arg4, Arg5) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg3,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg4,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg5,
gleamgen_ffi:identity(_pipe@4)
end]},
gleamgen@type_:tuple5(
type_(Arg1),
type_(Arg2),
type_(Arg3),
type_(Arg4),
type_(Arg5)
)}.
-file("src/gleamgen/expression.gleam", 341).
-spec tuple6(
expression(HQW),
expression(HQY),
expression(HRA),
expression(HRC),
expression(HRE),
expression(HRG)
) -> expression({HQW, HQY, HRA, HRC, HRE, HRG}).
tuple6(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg3,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg4,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg5,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg6,
gleamgen_ffi:identity(_pipe@5)
end]},
gleamgen@type_:tuple6(
type_(Arg1),
type_(Arg2),
type_(Arg3),
type_(Arg4),
type_(Arg5),
type_(Arg6)
)}.
-file("src/gleamgen/expression.gleam", 369).
-spec tuple7(
expression(HRJ),
expression(HRL),
expression(HRN),
expression(HRP),
expression(HRR),
expression(HRT),
expression(HRV)
) -> expression({HRJ, HRL, HRN, HRP, HRR, HRT, HRV}).
tuple7(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg3,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg4,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg5,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg6,
gleamgen_ffi:identity(_pipe@5)
end,
begin
_pipe@6 = Arg7,
gleamgen_ffi:identity(_pipe@6)
end]},
gleamgen@type_:tuple7(
type_(Arg1),
type_(Arg2),
type_(Arg3),
type_(Arg4),
type_(Arg5),
type_(Arg6),
type_(Arg7)
)}.
-file("src/gleamgen/expression.gleam", 400).
-spec tuple8(
expression(HRY),
expression(HSA),
expression(HSC),
expression(HSE),
expression(HSG),
expression(HSI),
expression(HSK),
expression(HSM)
) -> expression({HRY, HSA, HSC, HSE, HSG, HSI, HSK, HSM}).
tuple8(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg3,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg4,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg5,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg6,
gleamgen_ffi:identity(_pipe@5)
end,
begin
_pipe@6 = Arg7,
gleamgen_ffi:identity(_pipe@6)
end,
begin
_pipe@7 = Arg8,
gleamgen_ffi:identity(_pipe@7)
end]},
gleamgen@type_:tuple8(
type_(Arg1),
type_(Arg2),
type_(Arg3),
type_(Arg4),
type_(Arg5),
type_(Arg6),
type_(Arg7),
type_(Arg8)
)}.
-file("src/gleamgen/expression.gleam", 434).
-spec tuple9(
expression(HSP),
expression(HSR),
expression(HST),
expression(HSV),
expression(HSX),
expression(HSZ),
expression(HTB),
expression(HTD),
expression(HTF)
) -> expression({HSP, HSR, HST, HSV, HSX, HSZ, HTB, HTD, HTF}).
tuple9(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9) ->
{expression,
{tuple_literal,
[begin
_pipe = Arg1,
gleamgen_ffi:identity(_pipe)
end,
begin
_pipe@1 = Arg2,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg3,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg4,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg5,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg6,
gleamgen_ffi:identity(_pipe@5)
end,
begin
_pipe@6 = Arg7,
gleamgen_ffi:identity(_pipe@6)
end,
begin
_pipe@7 = Arg8,
gleamgen_ffi:identity(_pipe@7)
end,
begin
_pipe@8 = Arg9,
gleamgen_ffi:identity(_pipe@8)
end]},
gleamgen@type_:tuple9(
type_(Arg1),
type_(Arg2),
type_(Arg3),
type_(Arg4),
type_(Arg5),
type_(Arg6),
type_(Arg7),
type_(Arg8),
type_(Arg9)
)}.
-file("src/gleamgen/expression.gleam", 477).
?DOC(
" Provide an ident that could be of any type\n"
" Prefer using `raw_of_type`\n"
).
-spec raw(binary()) -> expression(any()).
raw(Value) ->
{expression, {ident, Value}, gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 482).
?DOC(false).
-spec raw_doc(glam@doc:document()) -> expression(any()).
raw_doc(Value) ->
{expression, {raw_doc, Value}, gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 487).
?DOC(false).
-spec imported_ident(
gleamgen@internal@import_reference:import_reference(),
binary()
) -> expression(any()).
imported_ident(Import_reference, Value) ->
{expression,
{imported_ident, Import_reference, Value},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 495).
?DOC(" Provide a string to inject without any checking of the specified type\n").
-spec raw_of_type(binary(), gleamgen@type_:generated_type(HTO)) -> expression(HTO).
raw_of_type(Value, Type_) ->
{expression, {ident, Value}, Type_}.
-file("src/gleamgen/expression.gleam", 503).
?DOC(false).
-spec imported_ident_of_type(
gleamgen@internal@import_reference:import_reference(),
binary(),
gleamgen@type_:generated_type(HTR)
) -> expression(HTR).
imported_ident_of_type(Import_reference, Value, Type_) ->
{expression, {imported_ident, Import_reference, Value}, Type_}.
-file("src/gleamgen/expression.gleam", 517).
?DOC(
" Use the <> operator to concatenate two strings.\n"
"\n"
" ```gleam\n"
" expression.concat_string(expression.raw(\"greeting\"), expression.string(\"world\"))\n"
" // Expression(String) -> greeting <> \"world\"\n"
" ```\n"
).
-spec concat_string(expression(binary()), expression(binary())) -> expression(binary()).
concat_string(Expr1, Expr2) ->
{expression,
{concat_string,
gleamgen_ffi:identity(Expr1),
gleamgen_ffi:identity(Expr2)},
generated_string}.
-file("src/gleamgen/expression.gleam", 530).
?DOC(
" Create a todo expression with an optional as clause.\n"
"\n"
" ```gleam\n"
" expression.todo_(option.Some(\"some unimplemented thing\"))\n"
" // Expression(a) -> \"todo as \\\"some unimplemented thing\\\"\"\n"
" ```\n"
).
-spec todo_(gleam@option:option(binary())) -> expression(any()).
todo_(As_string) ->
{expression, {todo, As_string}, gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 540).
?DOC(
" Create a panic expression with an optional as clause.\n"
"\n"
" ```gleam\n"
" expression.panic_(option.Some(\"ahhhhhh!!!\"))\n"
" // Expression(a) -> \"panic as \\\"ahhhhhh!!!\\\"\"\n"
" ```\n"
).
-spec panic_(gleam@option:option(binary())) -> expression(any()).
panic_(As_string) ->
{expression, {panic, As_string}, gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 545).
?DOC(" Create an assert expression with an optional as clause.\n").
-spec assert_(expression(boolean()), gleam@option:option(binary())) -> expression(nil).
assert_(Condition, As_string) ->
{expression,
{assert, gleamgen_ffi:identity(Condition), As_string},
generated_nil}.
-file("src/gleamgen/expression.gleam", 564).
?DOC(
" Create an echo expression with an optional as clause.\n"
"\n"
" ```gleam\n"
" expression.echo_(\n"
" expression.math_operator(\n"
" expression.int(2),\n"
" expression.Add,\n"
" expression.int(3),\n"
" ), \n"
" option.None\n"
" ) // Expression(Int) -> echo 2 + 3\n"
" ```\n"
).
-spec echo_(expression(HUG), gleam@option:option(binary())) -> expression(HUG).
echo_(Expression, As_string) ->
{expression,
{echo, gleamgen_ffi:identity(Expression), As_string},
erlang:element(3, Expression)}.
-file("src/gleamgen/expression.gleam", 577).
?DOC(
" Create an Ok value of the result type.\n"
"\n"
" ```gleam\n"
" expression.ok(expression.int(5))\n"
" // Expression(Result(Int, error)) -> Ok(5)\n"
" ```\n"
).
-spec ok(expression(HUK)) -> expression({ok, HUK} | {error, any()}).
ok(Ok_value) ->
{expression,
{call,
raw(<<"Ok"/utf8>>),
[begin
_pipe = Ok_value,
gleamgen_ffi:identity(_pipe)
end]},
gleamgen@type_:result(type_(Ok_value), gleamgen@type_:dynamic())}.
-file("src/gleamgen/expression.gleam", 590).
?DOC(
" Create an Error value of the result type.\n"
"\n"
" ```gleam\n"
" expression.error(expression.string(\"File not found\"))\n"
" // Expression(Result(ok, String)) -> Error(\"File not found\")\n"
" ```\n"
).
-spec error(expression(HUQ)) -> expression({ok, any()} | {error, HUQ}).
error(Err_value) ->
{expression,
{call,
raw(<<"Error"/utf8>>),
[begin
_pipe = Err_value,
gleamgen_ffi:identity(_pipe)
end]},
gleamgen@type_:result(gleamgen@type_:dynamic(), type_(Err_value))}.
-file("src/gleamgen/expression.gleam", 597).
-spec option_some(expression(HUW)) -> expression(gleam@option:option(HUW)).
option_some(Value) ->
{expression,
{call,
imported_ident(
gleamgen@internal@import_reference:new_implied_reference(
[<<"gleam"/utf8>>, <<"option"/utf8>>]
),
<<"Some"/utf8>>
),
[gleamgen_ffi:identity(Value)]},
gleamgen@type_:option(erlang:element(3, Value))}.
-file("src/gleamgen/expression.gleam", 610).
-spec option_none() -> expression(gleam@option:option(any())).
option_none() ->
{expression,
{single_constructor,
imported_ident(
gleamgen@internal@import_reference:new_implied_reference(
[<<"gleam"/utf8>>, <<"option"/utf8>>]
),
<<"None"/utf8>>
)},
gleamgen@type_:option(gleamgen@type_:dynamic())}.
-file("src/gleamgen/expression.gleam", 631).
?DOC(
" Apply the and operator to two expressions with the type of Bool.\n"
"\n"
" ```gleam\n"
" expression.and(expression.raw(\"has_cheese\"), expression.raw(\"wants_cheese\"))\n"
" // Expression(Bool) -> \"has_cheese && wants_cheese\"\n"
" ```\n"
).
-spec 'and'(expression(boolean()), expression(boolean())) -> expression(boolean()).
'and'(Expr1, Expr2) ->
{expression,
{bool_operator,
gleamgen_ffi:identity(Expr1),
'and',
gleamgen_ffi:identity(Expr2)},
generated_bool}.
-file("src/gleamgen/expression.gleam", 644).
?DOC(
" Apply the or operator to two expressions with the type of Bool.\n"
"\n"
" ```gleam\n"
" expression.or(expression.raw(\"wants_cake\"), expression.raw(\"wants_cheese\"))\n"
" // Expression(Bool) -> \"wants_cake || wants_cheese\"\n"
" ```\n"
).
-spec 'or'(expression(boolean()), expression(boolean())) -> expression(boolean()).
'or'(Expr1, Expr2) ->
{expression,
{bool_operator,
gleamgen_ffi:identity(Expr1),
'or',
gleamgen_ffi:identity(Expr2)},
generated_bool}.
-file("src/gleamgen/expression.gleam", 670).
?DOC(
" Apply a math operator to two expressions with the type of Int\n"
" ```gleam\n"
" expression.math_operator(expression.int(3), expression.Add, expression.int(5))\n"
" |> expression.render(render.default_context())\n"
" |> render.to_string()\n"
" // -> \"3 + 5\"\n"
" ```\n"
).
-spec math_operator(
expression(integer()),
math_operator(),
expression(integer())
) -> expression(integer()).
math_operator(Expr1, Op, Expr2) ->
{expression,
{math_operator,
gleamgen_ffi:identity(Expr1),
Op,
gleamgen_ffi:identity(Expr2)},
generated_int}.
-file("src/gleamgen/expression.gleam", 689).
?DOC(
" Apply a math operator to two expressions with the type of Float\n"
" ```gleam\n"
" expression.math_operator_float(\n"
" expression.float(3.3),\n"
" expression.Sub,\n"
" expression.unchecked_ident(\"other_float\")\n"
" )\n"
" |> expression.render(render.default_context())\n"
" |> render.to_string()\n"
" // -> \"3.3 -. other_float\"\n"
" ```\n"
).
-spec math_operator_float(
expression(float()),
math_operator(),
expression(float())
) -> expression(integer()).
math_operator_float(Expr1, Op, Expr2) ->
{expression,
{math_operator_float,
gleamgen_ffi:identity(Expr1),
Op,
gleamgen_ffi:identity(Expr2)},
generated_int}.
-file("src/gleamgen/expression.gleam", 700).
-spec comparison(expression(integer()), comparison(), expression(integer())) -> expression(boolean()).
comparison(Expr1, Operator, Expr2) ->
{expression,
{comparison,
gleamgen_ffi:identity(Expr1),
Operator,
gleamgen_ffi:identity(Expr2)},
generated_bool}.
-file("src/gleamgen/expression.gleam", 711).
-spec comparison_float(expression(float()), comparison(), expression(float())) -> expression(boolean()).
comparison_float(Expr1, Operator, Expr2) ->
{expression,
{comparison_float,
gleamgen_ffi:identity(Expr1),
Operator,
gleamgen_ffi:identity(Expr2)},
generated_bool}.
-file("src/gleamgen/expression.gleam", 729).
?DOC(
" Call a function or constructor with no arguments\n"
"\n"
" ```gleam\n"
" expression.call0(\n"
" import_.value_of_type(dict_module, \"new\", types.reference(dict.new))\n"
" ) // Expression(dict.Dict(key, value)) -> \"dict.new()\"\n"
" ```\n"
).
-spec call0(expression(fun(() -> HVV))) -> expression(HVV).
call0(Func) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 742).
?DOC(
" Call a function or constructor with one argument.\n"
"\n"
" ```gleam\n"
" expression.call1(\n"
" import_.value_of_type(list_module, \"is_empty\", types.reference(list.is_empty))\n"
" expression.list([])\n"
" ) // Expression(Bool) -> \"list.is_empty([])\"\n"
" ```\n"
" To call with a dynamic number of arguments, use [`call_dynamic`](#call_dynamic).\n"
).
-spec call1(expression(fun((HVY) -> HVZ)), expression(HVY)) -> expression(HVZ).
call1(Func, Arg1) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 757).
?DOC(
" Call a function or constructor with two arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call2(
expression(fun((HWD, HWE) -> HWF)),
expression(HWD),
expression(HWE)
) -> expression(HWF).
call2(Func, Arg1, Arg2) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 773).
?DOC(
" Call a function or constructor with three arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call3(
expression(fun((HWK, HWL, HWM) -> HWN)),
expression(HWK),
expression(HWL),
expression(HWM)
) -> expression(HWN).
call3(Func, Arg1, Arg2, Arg3) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg3,
gleamgen_ffi:identity(_pipe@3)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 791).
?DOC(
" Call a function or constructor with four arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call4(
expression(fun((HWT, HWU, HWV, HWW) -> HWX)),
expression(HWT),
expression(HWU),
expression(HWV),
expression(HWW)
) -> expression(HWX).
call4(Func, Arg1, Arg2, Arg3, Arg4) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg3,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg4,
gleamgen_ffi:identity(_pipe@4)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 811).
?DOC(
" Call a function or constructor with five arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call5(
expression(fun((HXE, HXF, HXG, HXH, HXI) -> HXJ)),
expression(HXE),
expression(HXF),
expression(HXG),
expression(HXH),
expression(HXI)
) -> expression(HXJ).
call5(Func, Arg1, Arg2, Arg3, Arg4, Arg5) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg3,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg4,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg5,
gleamgen_ffi:identity(_pipe@5)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 833).
?DOC(
" Call a function or constructor with six arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call6(
expression(fun((HXR, HXS, HXT, HXU, HXV, HXW) -> HXX)),
expression(HXR),
expression(HXS),
expression(HXT),
expression(HXU),
expression(HXV),
expression(HXW)
) -> expression(HXX).
call6(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg3,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg4,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg5,
gleamgen_ffi:identity(_pipe@5)
end,
begin
_pipe@6 = Arg6,
gleamgen_ffi:identity(_pipe@6)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 857).
?DOC(
" Call a function or constructor with seven arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call7(
expression(fun((HYG, HYH, HYI, HYJ, HYK, HYL, HYM) -> HYN)),
expression(HYG),
expression(HYH),
expression(HYI),
expression(HYJ),
expression(HYK),
expression(HYL),
expression(HYM)
) -> expression(HYN).
call7(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg3,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg4,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg5,
gleamgen_ffi:identity(_pipe@5)
end,
begin
_pipe@6 = Arg6,
gleamgen_ffi:identity(_pipe@6)
end,
begin
_pipe@7 = Arg7,
gleamgen_ffi:identity(_pipe@7)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 883).
?DOC(
" Call a function or constructor with eight arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call8(
expression(fun((HYX, HYY, HYZ, HZA, HZB, HZC, HZD, HZE) -> HZF)),
expression(HYX),
expression(HYY),
expression(HYZ),
expression(HZA),
expression(HZB),
expression(HZC),
expression(HZD),
expression(HZE)
) -> expression(HZF).
call8(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg3,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg4,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg5,
gleamgen_ffi:identity(_pipe@5)
end,
begin
_pipe@6 = Arg6,
gleamgen_ffi:identity(_pipe@6)
end,
begin
_pipe@7 = Arg7,
gleamgen_ffi:identity(_pipe@7)
end,
begin
_pipe@8 = Arg8,
gleamgen_ffi:identity(_pipe@8)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 911).
?DOC(
" Call a function or constructor with nine arguments.\n"
" See [`call1`](#call1).\n"
).
-spec call9(
expression(fun((HZQ, HZR, HZS, HZT, HZU, HZV, HZW, HZX, HZY) -> HZZ)),
expression(HZQ),
expression(HZR),
expression(HZS),
expression(HZT),
expression(HZU),
expression(HZV),
expression(HZW),
expression(HZX),
expression(HZY)
) -> expression(HZZ).
call9(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9) ->
{expression,
{call,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end,
[begin
_pipe@1 = Arg1,
gleamgen_ffi:identity(_pipe@1)
end,
begin
_pipe@2 = Arg2,
gleamgen_ffi:identity(_pipe@2)
end,
begin
_pipe@3 = Arg3,
gleamgen_ffi:identity(_pipe@3)
end,
begin
_pipe@4 = Arg4,
gleamgen_ffi:identity(_pipe@4)
end,
begin
_pipe@5 = Arg5,
gleamgen_ffi:identity(_pipe@5)
end,
begin
_pipe@6 = Arg6,
gleamgen_ffi:identity(_pipe@6)
end,
begin
_pipe@7 = Arg7,
gleamgen_ffi:identity(_pipe@7)
end,
begin
_pipe@8 = Arg8,
gleamgen_ffi:identity(_pipe@8)
end,
begin
_pipe@9 = Arg9,
gleamgen_ffi:identity(_pipe@9)
end]},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 944).
?DOC(" Call a function or constructor without type checking\n").
-spec call_dynamic(
expression(gleamgen@type_:dynamic_()),
list(expression(gleamgen@type_:dynamic_()))
) -> expression(gleamgen@type_:dynamic_()).
call_dynamic(Func, Args) ->
{expression, {call, Func, Args}, gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 951).
-spec construct0(expression(fun(() -> IAP))) -> expression(IAP).
construct0(Constructor) ->
{expression,
{single_constructor,
begin
_pipe = Constructor,
gleamgen_ffi:identity(_pipe)
end},
gleamgen@type_:dynamic()}.
-file("src/gleamgen/expression.gleam", 977).
?DOC(false).
-spec new_block(list(statement()), gleamgen@type_:generated_type(IAU)) -> expression(IAU).
new_block(Expressions, Return) ->
{expression, {block, Expressions}, Return}.
-file("src/gleamgen/expression.gleam", 982).
?DOC(false).
-spec update_or_create_block(
fun((list(statement())) -> list(statement())),
expression(IAY)
) -> expression(IAY).
update_or_create_block(Update_with, Next_expression) ->
case erlang:element(2, Next_expression) of
{block, Expressions} ->
{expression,
{block, Update_with(Expressions)},
erlang:element(3, Next_expression)};
_ ->
{expression,
{block,
Update_with(
[{expression_statement,
gleamgen_ffi:identity(Next_expression)}]
)},
erlang:element(3, Next_expression)}
end.
-file("src/gleamgen/expression.gleam", 1005).
?DOC(false).
-spec add_to_or_create_block(statement(), expression(IBB)) -> expression(IBB).
add_to_or_create_block(Update_with, Next_expression) ->
update_or_create_block(
fun(Statements) -> [Update_with | Statements] end,
Next_expression
).
-file("src/gleamgen/expression.gleam", 1016).
?DOC(false).
-spec new_use(
expression(any()),
list(expression(gleamgen@type_:dynamic_())),
list(binary())
) -> expression(gleamgen@type_:dynamic_()).
new_use(Function, Args, Callback_args) ->
Return = gleamgen@type_:get_return_type(erlang:element(3, Function)),
{expression,
{use,
begin
_pipe = Function,
gleamgen_ffi:identity(_pipe)
end,
Args,
Callback_args},
Return}.
-file("src/gleamgen/expression.gleam", 1029).
?DOC(false).
-spec new_case(
expression(gleamgen@type_:dynamic_()),
fun((gleamgen@internal@render:context()) -> list(fun((integer()) -> gleamgen@internal@render:rendered()))),
boolean(),
gleamgen@type_:generated_type(IBN)
) -> expression(IBN).
new_case(To_match_on, Patterns, All_can_match_on_multiple, Return) ->
{expression,
{'case', To_match_on, Patterns, All_can_match_on_multiple},
Return}.
-file("src/gleamgen/expression.gleam", 1042).
?DOC(false).
-spec new_anonymous_function(
fun((gleamgen@internal@render:context()) -> gleamgen@internal@render:rendered()),
expression(gleamgen@type_:dynamic_()),
list(gleamgen@parameter:parameter(gleamgen@type_:dynamic_())),
gleamgen@type_:generated_type(IBS)
) -> expression(IBS).
new_anonymous_function(Function, Function_body, Function_parameters, Return) ->
{expression,
{anonymous_function, Function, Function_body, Function_parameters},
Return}.
-file("src/gleamgen/expression.gleam", 1062).
?DOC(
" Return a new expression that will be rendered with a specific render config, \n"
" separate from the config used for the surrounding expression.\n"
" See the [`render`](render.html) module for more information.\n"
).
-spec with_render_config(expression(IBY), gleamgen@render@config:config()) -> expression(IBY).
with_render_config(Expression, Config) ->
{expression,
{with_config, gleamgen_ffi:identity(Expression), Config},
erlang:element(3, Expression)}.
-file("src/gleamgen/expression.gleam", 1083).
?DOC(" Convert an expression to any type without checking\n").
-spec coerce_dynamic_unsafe(expression(any())) -> expression(any()).
coerce_dynamic_unsafe(Type_) ->
gleamgen_ffi:identity(Type_).
-file("src/gleamgen/expression.gleam", 1612).
-spec is_minimal_ident(binary()) -> boolean().
is_minimal_ident(Ident) ->
_pipe = Ident,
_pipe@1 = gleam@string:to_graphemes(_pipe),
gleam@list:all(
_pipe@1,
fun(C) ->
(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((C =:= <<"_"/utf8>>)
orelse (C =:= <<"."/utf8>>))
orelse (C =:= <<"0"/utf8>>))
orelse (C =:= <<"1"/utf8>>))
orelse (C =:= <<"2"/utf8>>))
orelse (C =:= <<"3"/utf8>>))
orelse (C =:= <<"4"/utf8>>))
orelse (C =:= <<"5"/utf8>>))
orelse (C =:= <<"6"/utf8>>))
orelse (C =:= <<"7"/utf8>>))
orelse (C =:= <<"8"/utf8>>))
orelse (C =:= <<"9"/utf8>>))
orelse (C =:= <<"a"/utf8>>))
orelse (C =:= <<"b"/utf8>>))
orelse (C =:= <<"c"/utf8>>))
orelse (C =:= <<"d"/utf8>>))
orelse (C =:= <<"e"/utf8>>))
orelse (C =:= <<"f"/utf8>>))
orelse (C =:= <<"g"/utf8>>))
orelse (C =:= <<"h"/utf8>>))
orelse (C =:= <<"i"/utf8>>))
orelse (C =:= <<"j"/utf8>>))
orelse (C =:= <<"k"/utf8>>))
orelse (C =:= <<"l"/utf8>>))
orelse (C =:= <<"m"/utf8>>))
orelse (C =:= <<"n"/utf8>>))
orelse (C =:= <<"o"/utf8>>))
orelse (C =:= <<"p"/utf8>>))
orelse (C =:= <<"q"/utf8>>))
orelse (C =:= <<"r"/utf8>>))
orelse (C =:= <<"s"/utf8>>))
orelse (C =:= <<"t"/utf8>>))
orelse (C =:= <<"u"/utf8>>))
orelse (C =:= <<"v"/utf8>>))
orelse (C =:= <<"w"/utf8>>))
orelse (C =:= <<"x"/utf8>>))
orelse (C =:= <<"y"/utf8>>))
orelse (C =:= <<"z"/utf8>>))
orelse (C =:= <<"A"/utf8>>))
orelse (C =:= <<"B"/utf8>>))
orelse (C =:= <<"C"/utf8>>))
orelse (C =:= <<"D"/utf8>>))
orelse (C =:= <<"E"/utf8>>))
orelse (C =:= <<"F"/utf8>>))
orelse (C =:= <<"G"/utf8>>))
orelse (C =:= <<"H"/utf8>>))
orelse (C =:= <<"I"/utf8>>))
orelse (C =:= <<"J"/utf8>>))
orelse (C =:= <<"K"/utf8>>))
orelse (C =:= <<"L"/utf8>>))
orelse (C =:= <<"M"/utf8>>))
orelse (C =:= <<"N"/utf8>>))
orelse (C =:= <<"O"/utf8>>))
orelse (C =:= <<"P"/utf8>>))
orelse (C =:= <<"Q"/utf8>>))
orelse (C =:= <<"R"/utf8>>))
orelse (C =:= <<"S"/utf8>>))
orelse (C =:= <<"T"/utf8>>))
orelse (C =:= <<"U"/utf8>>))
orelse (C =:= <<"V"/utf8>>))
orelse (C =:= <<"W"/utf8>>))
orelse (C =:= <<"X"/utf8>>))
orelse (C =:= <<"Y"/utf8>>))
orelse (C =:= <<"Z"/utf8>>)
end
).
-file("src/gleamgen/expression.gleam", 1590).
-spec inline_with(
expression(gleamgen@type_:dynamic_()),
fun((expression(gleamgen@type_:dynamic_())) -> {ok,
expression(gleamgen@type_:dynamic_())} |
{error, nil}),
gleam@dict:dict(binary(), glam@doc:document())
) -> {ok, expression(gleamgen@type_:dynamic_())} | {error, nil}.
inline_with(Expression, Run_update, Rendered_parameters_by_name) ->
case erlang:element(2, Expression) of
{ident, Name} ->
case gleam_stdlib:map_get(Rendered_parameters_by_name, Name) of
{ok, Rendered_arg} ->
{ok,
{expression,
{raw_doc, Rendered_arg},
erlang:element(3, Expression)}};
{error, nil} ->
case is_minimal_ident(Name) of
true ->
{ok, Expression};
false ->
{error, nil}
end
end;
_ ->
Run_update(Expression)
end.
-file("src/gleamgen/expression.gleam", 1683).
-spec recursively_update_expression(
expression(gleamgen@type_:dynamic_()),
fun((expression(gleamgen@type_:dynamic_()), fun((expression(gleamgen@type_:dynamic_())) -> {ok,
expression(gleamgen@type_:dynamic_())} |
{error, nil})) -> {ok, expression(gleamgen@type_:dynamic_())} |
{error, nil})
) -> {ok, expression(gleamgen@type_:dynamic_())} | {error, nil}.
recursively_update_expression(Expression, Run_update) ->
Default_update = fun(Expr) ->
Updated_internal = case erlang:element(2, Expr) of
{call, Func, Args} ->
gleam@result:'try'(
recursively_update_expression(Func, Run_update),
fun(Updated_func) ->
gleam@result:'try'(
gleam@list:try_map(
Args,
fun(_capture) ->
recursively_update_expression(
_capture,
Run_update
)
end
),
fun(Updated_args) ->
{ok, {call, Updated_func, Updated_args}}
end
)
end
);
{'case', _, _, _} ->
{error, nil};
{raw_doc, _} ->
{error, nil};
{ident, _} ->
{error, nil};
{block, _} ->
{error, nil};
{anonymous_function, _, _, _} ->
{error, nil};
{use, _, _, _} ->
{error, nil};
{with_config, Expr@1, Config} ->
gleam@result:'try'(
recursively_update_expression(Expr@1, Run_update),
fun(Updated_expr) ->
{ok, {with_config, Updated_expr, Config}}
end
);
{field, Base, Name} ->
gleam@result:'try'(
recursively_update_expression(Base, Run_update),
fun(Updated_base) -> {ok, {field, Updated_base, Name}} end
);
{single_constructor, Constructor} ->
gleam@result:'try'(
recursively_update_expression(Constructor, Run_update),
fun(Updated_constructor) ->
{ok, {single_constructor, Updated_constructor}}
end
);
{list_literal, Elems, Initial} ->
gleam@result:'try'(
gleam@list:try_map(
Elems,
fun(_capture@1) ->
recursively_update_expression(
_capture@1,
Run_update
)
end
),
fun(Updated_elems) -> case Initial of
{some, Initial@1} ->
gleam@result:'try'(
recursively_update_expression(
Initial@1,
Run_update
),
fun(Updated_initial) ->
{ok,
{list_literal,
Updated_elems,
{some, Updated_initial}}}
end
);
none ->
{ok, {list_literal, Updated_elems, none}}
end end
);
{tuple_literal, Elems@1} ->
gleam@result:'try'(
gleam@list:try_map(
Elems@1,
fun(_capture@2) ->
recursively_update_expression(
_capture@2,
Run_update
)
end
),
fun(Updated_elems@1) ->
{ok, {tuple_literal, Updated_elems@1}}
end
);
{equals, Expr1, Expr2} ->
gleam@result:'try'(
recursively_update_expression(Expr1, Run_update),
fun(Updated_expr1) ->
gleam@result:'try'(
recursively_update_expression(Expr2, Run_update),
fun(Updated_expr2) ->
{ok, {equals, Updated_expr1, Updated_expr2}}
end
)
end
);
{not_equals, Expr1@1, Expr2@1} ->
gleam@result:'try'(
recursively_update_expression(Expr1@1, Run_update),
fun(Updated_expr1@1) ->
gleam@result:'try'(
recursively_update_expression(Expr2@1, Run_update),
fun(Updated_expr2@1) ->
{ok,
{not_equals,
Updated_expr1@1,
Updated_expr2@1}}
end
)
end
);
{concat_string, Expr1@2, Expr2@2} ->
gleam@result:'try'(
recursively_update_expression(Expr1@2, Run_update),
fun(Updated_expr1@2) ->
gleam@result:'try'(
recursively_update_expression(Expr2@2, Run_update),
fun(Updated_expr2@2) ->
{ok,
{concat_string,
Updated_expr1@2,
Updated_expr2@2}}
end
)
end
);
{math_operator, Expr1@3, Op, Expr2@3} ->
gleam@result:'try'(
recursively_update_expression(Expr1@3, Run_update),
fun(Updated_expr1@3) ->
gleam@result:'try'(
recursively_update_expression(Expr2@3, Run_update),
fun(Updated_expr2@3) ->
{ok,
{math_operator,
Updated_expr1@3,
Op,
Updated_expr2@3}}
end
)
end
);
{math_operator_float, Expr1@4, Op@1, Expr2@4} ->
gleam@result:'try'(
recursively_update_expression(Expr1@4, Run_update),
fun(Updated_expr1@4) ->
gleam@result:'try'(
recursively_update_expression(Expr2@4, Run_update),
fun(Updated_expr2@4) ->
{ok,
{math_operator_float,
Updated_expr1@4,
Op@1,
Updated_expr2@4}}
end
)
end
);
{comparison, Expr1@5, Operator, Expr2@5} ->
gleam@result:'try'(
recursively_update_expression(Expr1@5, Run_update),
fun(Updated_expr1@5) ->
gleam@result:'try'(
recursively_update_expression(Expr2@5, Run_update),
fun(Updated_expr2@5) ->
{ok,
{comparison,
Updated_expr1@5,
Operator,
Updated_expr2@5}}
end
)
end
);
{bool_operator, Expr1@6, Operator@1, Expr2@6} ->
gleam@result:'try'(
recursively_update_expression(Expr1@6, Run_update),
fun(Updated_expr1@6) ->
gleam@result:'try'(
recursively_update_expression(Expr2@6, Run_update),
fun(Updated_expr2@6) ->
{ok,
{bool_operator,
Updated_expr1@6,
Operator@1,
Updated_expr2@6}}
end
)
end
);
{comparison_float, Expr1@7, Operator@2, Expr2@7} ->
gleam@result:'try'(
recursively_update_expression(Expr1@7, Run_update),
fun(Updated_expr1@7) ->
gleam@result:'try'(
recursively_update_expression(Expr2@7, Run_update),
fun(Updated_expr2@7) ->
{ok,
{comparison_float,
Updated_expr1@7,
Operator@2,
Updated_expr2@7}}
end
)
end
);
{echo, Expression@1, As_string} ->
gleam@result:'try'(
recursively_update_expression(Expression@1, Run_update),
fun(Updated_expression) ->
{ok, {echo, Updated_expression, As_string}}
end
);
{assert, Condition, As_string@1} ->
gleam@result:'try'(
recursively_update_expression(Condition, Run_update),
fun(Updated_condition) ->
{ok, {assert, Updated_condition, As_string@1}}
end
);
{int_literal, _} ->
{ok, erlang:element(2, Expr)};
{str_literal, _} ->
{ok, erlang:element(2, Expr)};
{bool_literal, _} ->
{ok, erlang:element(2, Expr)};
{float_literal, _} ->
{ok, erlang:element(2, Expr)};
{panic, _} ->
{ok, erlang:element(2, Expr)};
{todo, _} ->
{ok, erlang:element(2, Expr)};
{imported_ident, _, _} ->
{ok, erlang:element(2, Expr)};
nil_literal ->
{ok, erlang:element(2, Expr)}
end,
gleam@result:'try'(
Updated_internal,
fun(Internal) ->
{ok, {expression, Internal, erlang:element(3, Expr)}}
end
)
end,
Run_update(Expression, Default_update).
-file("src/gleamgen/expression.gleam", 1514).
-spec do_remove_incorrect_empty_lines(
list(statement()),
list(statement()),
boolean()
) -> list(statement()).
do_remove_incorrect_empty_lines(Statements, Acc, Was_just_empty_line) ->
case Statements of
[] ->
lists:reverse(Acc);
[linebreak | Rest] ->
do_remove_incorrect_empty_lines(Rest, Acc, true);
[Other | Rest@1] when Was_just_empty_line ->
do_remove_incorrect_empty_lines(
Rest@1,
[Other, linebreak | Acc],
false
);
[Other@1 | Rest@2] ->
do_remove_incorrect_empty_lines(Rest@2, [Other@1 | Acc], false)
end.
-file("src/gleamgen/expression.gleam", 1507).
-spec remove_incorrect_empty_lines(list(statement())) -> list(statement()).
remove_incorrect_empty_lines(Statements) ->
Trimmed_beginning = gleam@list:drop_while(
Statements,
fun(Statement) -> Statement =:= linebreak end
),
do_remove_incorrect_empty_lines(Trimmed_beginning, [], false).
-file("src/gleamgen/expression.gleam", 1554).
-spec inline_anonymous_function_args(
expression(any()),
list(glam@doc:document()),
gleamgen@internal@render:rendered_details(),
gleamgen@internal@render:context()
) -> {ok, gleamgen@internal@render:rendered()} | {error, nil}.
inline_anonymous_function_args(
Function_expression,
Rendered_args,
Details,
Context
) ->
case erlang:element(2, Function_expression) of
{anonymous_function, _, Body, Parameters} when erlang:element(
5,
erlang:element(2, Context)
) ->
gleam@bool:guard(
erlang:length(Parameters) /= erlang:length(Rendered_args),
{error, nil},
fun() ->
Rendered_parameters_by_name = begin
_pipe = Parameters,
_pipe@1 = gleam@list:map(
_pipe,
fun(Parameter) ->
gleamgen@parameter:name(Parameter)
end
),
_pipe@2 = gleam@list:zip(_pipe@1, Rendered_args),
maps:from_list(_pipe@2)
end,
gleam@result:'try'(
recursively_update_expression(
Body,
fun(Expr, Run_update) ->
inline_with(
Expr,
Run_update,
Rendered_parameters_by_name
)
end
),
fun(Inlined_body) ->
Rendered_inlined_body = render(
Inlined_body,
Context
),
{ok,
{render,
erlang:element(2, Rendered_inlined_body),
gleamgen@internal@render:merge_details(
Details,
erlang:element(3, Rendered_inlined_body)
)}}
end
)
end
);
_ ->
{error, nil}
end.
-file("src/gleamgen/expression.gleam", 1525).
-spec render_expressions(
list(expression(gleamgen@type_:dynamic_())),
gleamgen@internal@render:context()
) -> {list(glam@doc:document()), gleamgen@internal@render:rendered_details()}.
render_expressions(Expressions, Context) ->
{Rendered@1, Details} = gleam@list:fold(
Expressions,
{[], {rendered_details, [], [], {report, [], []}}},
fun(Acc, Expr) ->
Rendered = render(Expr, Context),
{[erlang:element(2, Rendered) | erlang:element(1, Acc)],
gleamgen@internal@render:merge_details(
erlang:element(3, Rendered),
erlang:element(2, Acc)
)}
end
),
{begin
_pipe = Rendered@1,
lists:reverse(_pipe)
end,
Details}.
-file("src/gleamgen/expression.gleam", 1537).
-spec render_call(
expression(gleamgen@type_:dynamic_()),
list(expression(gleamgen@type_:dynamic_())),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_call(Func, Args, Context) ->
Arg_context = {context,
erlang:element(2, Context),
erlang:element(3, Context),
true},
{Rendered_args, Details} = render_expressions(Args, Arg_context),
case inline_anonymous_function_args(Func, Rendered_args, Details, Context) of
{ok, Inlined} ->
Inlined;
{error, nil} ->
Caller = render(Func, Context),
_pipe = glam@doc:concat(
[erlang:element(2, Caller),
gleamgen@internal@render:pretty_list(Rendered_args)]
),
{render,
_pipe,
gleamgen@internal@render:merge_details(
Details,
erlang:element(3, Caller)
)}
end.
-file("src/gleamgen/expression.gleam", 1298).
-spec render_use(
expression(gleamgen@type_:dynamic_()),
list(expression(gleamgen@type_:dynamic_())),
list(binary()),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_use(Func, Args, Callback_args, Context) ->
Use_args = begin
_pipe = Callback_args,
_pipe@1 = gleam@list:map(_pipe, fun glam@doc:from_string/1),
_pipe@2 = glam@doc:join(
_pipe@1,
glam@doc:concat(
[glam@doc:from_string(<<","/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>}]
)
),
glam@doc:append(_pipe@2, case gleam@list:is_empty(Callback_args) of
true ->
{concat, []};
false ->
{break, <<" "/utf8>>, <<""/utf8>>}
end)
end,
Call = render_call(Func, Args, Context),
_pipe@3 = glam@doc:concat(
[glam@doc:from_string(<<"use"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
Use_args,
glam@doc:from_string(<<"<-"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
erlang:element(2, Call)]
),
{render, _pipe@3, erlang:element(3, Call)}.
-file("src/gleamgen/expression.gleam", 1321).
-spec render_case(
expression(gleamgen@type_:dynamic_()),
fun((gleamgen@internal@render:context()) -> list(fun((integer()) -> gleamgen@internal@render:rendered()))),
boolean(),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_case(To_match_on, Patterns, All_can_match_on_multiple, Context) ->
{Rendered_match_on@1, Subject_count} = case erlang:element(2, To_match_on) of
{tuple_literal, Expressions} when All_can_match_on_multiple ->
{Expressions@1, Details} = render_expressions(Expressions, Context),
Rendered_match_on = begin
_pipe = Expressions@1,
_pipe@1 = glam@doc:concat_join(
_pipe,
[glam@doc:from_string(<<","/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>}]
),
{render, _pipe@1, Details}
end,
{Rendered_match_on, erlang:length(Expressions@1)};
_ ->
{render(To_match_on, Context), 1}
end,
Patterns@1 = gleam@list:map(
Patterns(Context),
fun(M) -> M(Subject_count) end
),
Matcher_details = gleam@list:fold(
gleam@list:map(Patterns@1, fun(M@1) -> erlang:element(3, M@1) end),
{rendered_details, [], [], {report, [], []}},
fun gleamgen@internal@render:merge_details/2
),
_pipe@4 = glam@doc:concat(
[glam@doc:from_string(<<"case "/utf8>>),
erlang:element(2, Rendered_match_on@1),
{break, <<" "/utf8>>, <<""/utf8>>},
gleamgen@internal@render:body(
begin
_pipe@2 = Patterns@1,
_pipe@3 = gleam@list:map(
_pipe@2,
fun(M@2) -> erlang:element(2, M@2) end
),
glam@doc:join(_pipe@3, {line, 1})
end,
true
)]
),
{render,
_pipe@4,
gleamgen@internal@render:merge_details(
erlang:element(3, Rendered_match_on@1),
Matcher_details
)}.
-file("src/gleamgen/expression.gleam", 1877).
-spec render_operator(
expression(IEY),
expression(IEY),
glam@doc:document(),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_operator(Expr1, Expr2, Rendered_op, Context) ->
First_rendered = render(Expr1, Context),
Second_rendered = render(Expr2, Context),
_pipe = glam@doc:concat(
[erlang:element(2, First_rendered),
{break, <<" "/utf8>>, <<""/utf8>>},
Rendered_op,
{break, <<" "/utf8>>, <<""/utf8>>},
erlang:element(2, Second_rendered)]
),
{render,
_pipe,
gleamgen@internal@render:merge_details(
erlang:element(3, First_rendered),
erlang:element(3, Second_rendered)
)}.
-file("src/gleamgen/expression.gleam", 1405).
?DOC(false).
-spec render_statement(statement(), gleamgen@internal@render:context()) -> gleamgen@internal@render:rendered().
render_statement(Statement, Context) ->
case Statement of
{let_declaration, Pattern_renderer, Value, Assert_} ->
Rendered_value = render(Value, Context),
Let_def = case Assert_ of
true ->
<<"let assert "/utf8>>;
false ->
<<"let "/utf8>>
end,
Rendered_pattern = Pattern_renderer(Context),
Details = gleamgen@internal@render:merge_details(
erlang:element(3, Rendered_value),
erlang:element(3, Rendered_pattern)
),
{Type_annotation, Details@1} = case gleamgen@type_:render_type(
erlang:element(3, Value),
Context
) of
{ok, Rendered_type} when erlang:element(
6,
erlang:element(2, Context)
) ->
{glam@doc:concat(
[glam@doc:from_string(<<":"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
erlang:element(2, Rendered_type)]
),
gleamgen@internal@render:merge_details(
Details,
erlang:element(3, Rendered_type)
)};
_ ->
{{concat, []}, Details}
end,
_pipe = glam@doc:concat(
[glam@doc:from_string(Let_def),
erlang:element(2, Rendered_pattern),
Type_annotation,
{break, <<" "/utf8>>, <<""/utf8>>},
glam@doc:from_string(<<"="/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
erlang:element(2, Rendered_value)]
),
{render, _pipe, Details@1};
{comment, Comments} ->
_pipe@1 = Comments,
_pipe@2 = gleam@list:map(
_pipe@1,
fun(Comment) ->
glam@doc:from_string(<<"// "/utf8, Comment/binary>>)
end
),
_pipe@3 = glam@doc:join(_pipe@2, {line, 1}),
{render, _pipe@3, {rendered_details, [], [], {report, [], []}}};
linebreak ->
{render, {concat, []}, {rendered_details, [], [], {report, [], []}}};
{expression_statement,
{expression,
{with_config, {expression, {block, Statements}, _}, Config},
_}} ->
render_block(
Statements,
{context, Config, erlang:element(3, Context), false}
);
{expression_statement, Expr} ->
render(Expr, Context)
end.
-file("src/gleamgen/expression.gleam", 1484).
-spec render_block_multi_statement(
list(statement()),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_block_multi_statement(Statements, Context) ->
{Inner_statements, Details} = gleam@list:fold(
Statements,
{[], {rendered_details, [], [], {report, [], []}}},
fun(Acc, Statement) ->
Rendered = render_statement(
Statement,
{context,
erlang:element(2, Context),
erlang:element(3, Context),
true}
),
{[erlang:element(2, Rendered) | erlang:element(1, Acc)],
gleamgen@internal@render:merge_details(
erlang:element(3, Rendered),
erlang:element(2, Acc)
)}
end
),
Inner = begin
_pipe = Inner_statements,
_pipe@1 = lists:reverse(_pipe),
glam@doc:join(_pipe@1, {line, 1})
end,
_pipe@2 = case erlang:element(4, Context) of
true ->
gleamgen@internal@render:body(Inner, true);
false ->
Inner
end,
{render, _pipe@2, Details}.
-file("src/gleamgen/expression.gleam", 1469).
-spec render_block(list(statement()), gleamgen@internal@render:context()) -> gleamgen@internal@render:rendered().
render_block(Statements, Context) ->
Corrected_statements = remove_incorrect_empty_lines(Statements),
case Corrected_statements of
[{expression_statement, Expr}] ->
render(
Expr,
{context,
erlang:element(2, Context),
erlang:element(3, Context),
true}
);
_ ->
render_block_multi_statement(Corrected_statements, Context)
end.
-file("src/gleamgen/expression.gleam", 1873).
-spec render_constructor(
expression(gleamgen@type_:dynamic_()),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_constructor(Func, Context) ->
render(Func, Context).
-file("src/gleamgen/expression.gleam", 1281).
-spec render_panicking_expression(
glam@doc:document(),
gleam@option:option(binary())
) -> glam@doc:document().
render_panicking_expression(Begin_with, As_string) ->
case As_string of
{some, Value} ->
_pipe@2 = glam@doc:concat(
[Begin_with,
glam@doc:from_string(<<" as"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
begin
_pipe = Value,
_pipe@1 = gleamgen@internal@render:escape_string(_pipe),
glam@doc:from_string(_pipe@1)
end]
),
glam@doc:group(_pipe@2);
none ->
Begin_with
end.
-file("src/gleamgen/expression.gleam", 1255).
-spec create_echo(
expression(gleamgen@type_:dynamic_()),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
create_echo(Expression, Context) ->
Rendered_expr = render(Expression, Context),
_pipe = glam@doc:concat(
[glam@doc:from_string(<<"echo"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
erlang:element(2, Rendered_expr)]
),
{render, _pipe, erlang:element(3, Rendered_expr)}.
-file("src/gleamgen/expression.gleam", 1268).
-spec create_assert(
expression(gleamgen@type_:dynamic_()),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
create_assert(Condition, Context) ->
Rendered_condition = render(Condition, Context),
_pipe = glam@doc:concat(
[glam@doc:from_string(<<"assert"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
erlang:element(2, Rendered_condition)]
),
{render, _pipe, erlang:element(3, Rendered_condition)}.
-file("src/gleamgen/expression.gleam", 1241).
-spec render_field(
expression(gleamgen@type_:dynamic_()),
binary(),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_field(Base, Field, Context) ->
Rendered_base = render(Base, Context),
_pipe = glam@doc:concat(
[erlang:element(2, Rendered_base),
glam@doc:from_string(<<"."/utf8>>),
glam@doc:from_string(Field)]
),
{render, _pipe, erlang:element(3, Rendered_base)}.
-file("src/gleamgen/expression.gleam", 1365).
-spec render_tuple(
list(expression(gleamgen@type_:dynamic_())),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_tuple(Values, Context) ->
{Rendered_values, Details} = render_expressions(Values, Context),
_pipe = Rendered_values,
_pipe@1 = gleamgen@internal@render:pretty_list(_pipe),
_pipe@2 = glam@doc:prepend(_pipe@1, glam@doc:from_string(<<"#"/utf8>>)),
{render, _pipe@2, Details}.
-file("src/gleamgen/expression.gleam", 1373).
-spec render_list(
list(expression(gleamgen@type_:dynamic_())),
gleam@option:option(expression(gleamgen@type_:dynamic_())),
gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_list(Values, Initial_list, Context) ->
Comma = glam@doc:concat(
[glam@doc:from_string(<<","/utf8>>), {break, <<" "/utf8>>, <<""/utf8>>}]
),
{Ending, Trailing_comma} = case Initial_list of
{some, Initial} ->
{glam@doc:concat(
[glam@doc:from_string(<<","/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
glam@doc:from_string(<<".."/utf8>>),
erlang:element(2, render(Initial, Context))]
),
{break, <<""/utf8>>, <<""/utf8>>}};
none ->
{{concat, []}, glam@doc:break(<<""/utf8>>, <<","/utf8>>)}
end,
Open_bracket = glam@doc:concat(
[glam@doc:from_string(<<"["/utf8>>), {break, <<""/utf8>>, <<""/utf8>>}]
),
Close_bracket = glam@doc:concat(
[Trailing_comma, glam@doc:from_string(<<"]"/utf8>>)]
),
{Rendered_values, Details} = render_expressions(Values, Context),
_pipe = Rendered_values,
_pipe@1 = glam@doc:join(_pipe, Comma),
_pipe@2 = glam@doc:prepend(_pipe@1, Open_bracket),
_pipe@3 = glam@doc:append(_pipe@2, Ending),
_pipe@4 = glam@doc:nest(_pipe@3, 2),
_pipe@5 = glam@doc:append(_pipe@4, Close_bracket),
_pipe@6 = glam@doc:group(_pipe@5),
{render, _pipe@6, Details}.
-file("src/gleamgen/expression.gleam", 1107).
?DOC(
" Render an expression. See the [`render`](render.html) module for more information.\n"
" In general, prefer rendering at the module level, rather than individual expressions.\n"
).
-spec render(expression(any()), gleamgen@internal@render:context()) -> gleamgen@internal@render:rendered().
render(Expression, Context) ->
case erlang:element(2, Expression) of
{int_literal, Value} ->
_pipe = Value,
_pipe@1 = erlang:integer_to_binary(_pipe),
_pipe@2 = glam@doc:from_string(_pipe@1),
{render, _pipe@2, {rendered_details, [], [], {report, [], []}}};
{float_literal, Value@1} ->
_pipe@3 = Value@1,
_pipe@4 = gleam_stdlib:float_to_string(_pipe@3),
_pipe@5 = glam@doc:from_string(_pipe@4),
{render, _pipe@5, {rendered_details, [], [], {report, [], []}}};
{str_literal, Value@2} ->
_pipe@6 = gleamgen@internal@render:escape_string(Value@2),
_pipe@7 = glam@doc:from_string(_pipe@6),
{render, _pipe@7, {rendered_details, [], [], {report, [], []}}};
{bool_literal, true} ->
_pipe@8 = glam@doc:from_string(<<"True"/utf8>>),
{render, _pipe@8, {rendered_details, [], [], {report, [], []}}};
{bool_literal, false} ->
_pipe@9 = glam@doc:from_string(<<"False"/utf8>>),
{render, _pipe@9, {rendered_details, [], [], {report, [], []}}};
nil_literal ->
_pipe@10 = glam@doc:from_string(<<"Nil"/utf8>>),
{render, _pipe@10, {rendered_details, [], [], {report, [], []}}};
{list_literal, Values, Initial_list} ->
render_list(Values, Initial_list, Context);
{tuple_literal, Values@1} ->
render_tuple(Values@1, Context);
{ident, Value@3} ->
Used_imports = case {gleam@string:split_once(Value@3, <<"."/utf8>>),
is_minimal_ident(Value@3)} of
{{ok, {Module, _}}, true} ->
[Module];
{_, _} ->
[]
end,
_pipe@11 = glam@doc:from_string(Value@3),
{render,
_pipe@11,
begin
_record = {rendered_details, [], [], {report, [], []}},
{rendered_details,
Used_imports,
erlang:element(3, _record),
erlang:element(4, _record)}
end};
{field, Base, Field} ->
render_field(Base, Field, Context);
{imported_ident, Module@1, Value@4} ->
Module_to_use = gleamgen@internal@render:get_import_from_context(
Context,
Module@1
),
Representation = gleamgen@internal@import_reference:get_reference(
Module_to_use,
Value@4
),
_pipe@12 = Representation,
{render,
_pipe@12,
gleamgen@internal@render:add_import_to_details(
{rendered_details, [], [], {report, [], []}},
Module@1
)};
{raw_doc, Doc} ->
{render, Doc, {rendered_details, [], [], {report, [], []}}};
{todo, As_string} ->
_pipe@13 = render_panicking_expression(
glam@doc:from_string(<<"todo"/utf8>>),
As_string
),
{render, _pipe@13, {rendered_details, [], [], {report, [], []}}};
{panic, As_string@1} ->
_pipe@14 = render_panicking_expression(
glam@doc:from_string(<<"panic"/utf8>>),
As_string@1
),
{render, _pipe@14, {rendered_details, [], [], {report, [], []}}};
{assert, Condition, As_string@2} ->
Assert_ = create_assert(Condition, Context),
_pipe@15 = render_panicking_expression(
erlang:element(2, Assert_),
As_string@2
),
{render, _pipe@15, erlang:element(3, Assert_)};
{echo, Expression@1, As_string@3} ->
Echo_ = create_echo(Expression@1, Context),
_pipe@16 = render_panicking_expression(
erlang:element(2, Echo_),
As_string@3
),
{render, _pipe@16, erlang:element(3, Echo_)};
{concat_string, Expr1, Expr2} ->
render_operator(
Expr1,
Expr2,
glam@doc:from_string(<<"<>"/utf8>>),
Context
);
{bool_operator, Expr1@1, 'and', Expr2@1} ->
render_operator(
Expr1@1,
Expr2@1,
glam@doc:from_string(<<"&&"/utf8>>),
Context
);
{bool_operator, Expr1@2, 'or', Expr2@2} ->
render_operator(
Expr1@2,
Expr2@2,
glam@doc:from_string(<<"||"/utf8>>),
Context
);
{math_operator, Expr1@3, Op, Expr2@3} ->
render_operator(Expr1@3, Expr2@3, case Op of
add ->
glam@doc:from_string(<<"+"/utf8>>);
sub ->
glam@doc:from_string(<<"-"/utf8>>);
mul ->
glam@doc:from_string(<<"*"/utf8>>);
'div' ->
glam@doc:from_string(<<"/"/utf8>>)
end, Context);
{math_operator_float, Expr1@4, Op@1, Expr2@4} ->
render_operator(Expr1@4, Expr2@4, case Op@1 of
add ->
glam@doc:from_string(<<"+."/utf8>>);
sub ->
glam@doc:from_string(<<"-."/utf8>>);
mul ->
glam@doc:from_string(<<"*."/utf8>>);
'div' ->
glam@doc:from_string(<<"/."/utf8>>)
end, Context);
{comparison, Expr1@5, Operator, Expr2@5} ->
Operator_doc = case Operator of
greater_than ->
glam@doc:from_string(<<">"/utf8>>);
greater_than_or_equal ->
glam@doc:from_string(<<">="/utf8>>);
less_than ->
glam@doc:from_string(<<"<"/utf8>>);
less_than_or_equal ->
glam@doc:from_string(<<"<="/utf8>>)
end,
render_operator(Expr1@5, Expr2@5, Operator_doc, Context);
{comparison_float, Expr1@6, Operator@1, Expr2@6} ->
Operator_doc@1 = case Operator@1 of
greater_than ->
glam@doc:from_string(<<">."/utf8>>);
greater_than_or_equal ->
glam@doc:from_string(<<">=."/utf8>>);
less_than ->
glam@doc:from_string(<<"<."/utf8>>);
less_than_or_equal ->
glam@doc:from_string(<<"<=."/utf8>>)
end,
render_operator(Expr1@6, Expr2@6, Operator_doc@1, Context);
{call, Func, Args} ->
render_call(Func, Args, Context);
{single_constructor, Constructor} ->
render_constructor(Constructor, Context);
{block, Expressions} ->
render_block(Expressions, Context);
{equals, Expr1@7, Expr2@7} ->
render_operator(
Expr1@7,
Expr2@7,
glam@doc:from_string(<<"=="/utf8>>),
Context
);
{not_equals, Expr1@8, Expr2@8} ->
render_operator(
Expr1@8,
Expr2@8,
glam@doc:from_string(<<"!="/utf8>>),
Context
);
{'case', To_match_on, Patterns, All_can_match_on_multiple} ->
render_case(
To_match_on,
Patterns,
All_can_match_on_multiple,
Context
);
{anonymous_function, Renderer, _, _} ->
Renderer(Context);
{use, Func@1, Args@1, Callback_args} ->
render_use(Func@1, Args@1, Callback_args, Context);
{with_config, Expr, Config} ->
render(
gleamgen_ffi:identity(Expr),
{context,
Config,
erlang:element(3, Context),
erlang:element(4, Context)}
)
end.