This page presents all the <Computation>
s that can be performed in Wyrd.
<Computation>
s do not modify the memory, but they always return a <Value>
.
Be careful not to modify the memory through reference when computing values.
Shortcut to each <Computation>
:
(add_text_effect {name: String} {parameters: <Computation> List} {values: <Computation> list})
(address <value_or_target: Computation>)
(cast {from: String} {to: String} <value: Computation>)
(constant {type: String} {value: String})
(get_allocable_address)
(if_else <condition: Computation> <if_true: Computation> <if_false: Computation>)
(last_choice_index)
(newline)
(operation {operator: String} <x: Computation>)
(operation {operator: String} <x: Computation> <y: Computation>)
(relative_address <target: Computation> <extra: Computation>)
(size <target: Computation>)
(text {values: <Computation> List})
(value_of <target: Computation>)
({extra_computation} {parameters: <Computation> List})
(add_text_effect {name: String} {parameters: <Computation> List} {values: <Computation> list})
Add an effect to a list of texts, returning it as a single text.
Parameters:
name
is a {String}
indicating the name of the effect.parameters
is a {List}
of <Computation>
that will yield the <Value>
s
used as parameters for the effect.values
is a {<Computation> List}
that will yield the texts to merge and
apply the effect to. These will yield <TextValue>
s.Process:
{params: <Value> List}
corresponding to parameters
(keep the
order).{texts: <Value> List}
corresponding to values
(keep the
order).<AugmentedText>
<TextValue>
with texts
as content
,
name
as effect_name
, and params
as effect_parameters
.(address <value_or_target: Computation>)
Converts to an address.
Parameters:
value_or_target
is a <Computation>
that will either result in in a
<PointerValue>
or a <StringValue>
.Process:
<Value>
corresponding to value_or_target
.<PointerValue>
, return the value as is.<StringValue>
, interpret the value as
{addr: String}
, return a new <PointerValue>
built from a singleton list
with addr
as its only element.(cast {from: String} {to: String} <value: Computation>)
Convert from one type to another.
Parameters:
from
is a {String}
naming the type content
will result to.to
is a {String}
naming the type to convert content
to.content
is a <Computation>
that will yield the <Value>
to convert.Process:
<Value>
associate with content
.<Value>
from from
to to
.Note: The following conversions are expected to be available:
<BoolValue>
to <StringValue>
, returning (StringValue "true")
if
<Value>
is (BoolValue TRUE)
and (StringValue "false")
otherwise.<BoolValue>
to <TextValue>
, same as above, but with text instead of
string.<FloatValue>
to <StringValue>
.<FloatValue>
to <TextValue>
.<FloatValue>
to <IntValue>
, using a floor function.<IntValue>
to <StringValue>
.<IntValue>
to <TextValue>
.<IntValue>
to <FloatValue>
.<IntValue>
to <BoolValue>
, with 0
being (BoolValue FALSE)
and
anything else being (BoolValue TRUE)
.<StringValue>
to <FloatValue>
.<StringValue>
to <IntValue>
.<StringValue>
to <BoolValue>
, (BoolValue TRUE)
if the string is
"true"
, (BoolValue FALSE)
if it is "false"
. Convert to lowercase prior
to checking.<TextValue>
to <StringValue>
, by recursively converting all content to
{String}
, discarding effects and newlines, and appending it all.<TextValue>
to <IntValue>
, by converting it to <StringValue>
first.<TextValue>
to <FloatValue>
, by converting it to <StringValue>
first.<TextValue>
to <BoolValue>
, by converting it to <StringValue>
first.(constant {type: String} {value: String})
Constant value.
Parameters:
type
is a {String}
indicating the type the other parameter should be
converted to.value
is a {String}
representation of the value that should be returned.Process:
value
according to type
.<Value>
.Notes:
The type
parameter can take the following values: "string"
, "float"
,
"int"
, and "bool"
.
(get_allocable_address)
Get an allocable address.
Process:
<PointerValue>
corresponding to an unused address.Notes:
Process when using the suggested <State>
definition:
<State>
’s freed_addresses
collection has elements, return a
<PointerValue>
corresponding to one of its elements.addr
corresponding to ".alloc."
to which the
<State>
’s allocated_data
integer has been added then return a new
<PointerValue>
with a singleton list containing addr
.
As a reminder, <State>
is not modified by the procedure.(if_else <condition: Computation> <if_true: Computation> <if_false: Computation>)
Parameters:
condition
is a <Computation>
that will indicate which other computation to
consider.if_true
is a <Computation>
that will be considered only if the condition
is verified.if_false
is a <Computation>
that will be considered only if the condition
is not verified.Process:
<BoolValue>
resulting from condition
.<BoolValue>
as a {Boolean}
.TRUE
, compute and return the <Value>
resulting from
if_true
, otherwise, compute and return the <Value>
resulting from
if_false
.(last_choice_index)
Get the index of the user’s last chosen option.
Process:
<IntValue>
corresponding to the <State>
’s last_choice_index
.(newline)
Return a newline value.
Process:
<TextValue>
corresponding to a newline.(operation {operator: String} <x: Computation>)
Interpret as (operation operator x (BoolValue FALSE))
. It is recommended to
have the parser do that conversion automatically.
(operation {operator: String} <x: Computation> <y: Computation>)
Performs a basic operation.
Parameters:
operator
is the name of the operation.x
is the first operand.y
is the second operand.Process:
<val_x: Value>
and <val_y: Value>
, the <Values>
corresponding to
x
and y
, respectively.Notes:
val_x
and val_y
always have the same type. If the returned value is a
number, it has the same type as val_x
and val_y
. Number types are
<FloatValue>
and <IntValue>
. Comparable types are <FloatType>
,
<IntValue>
, <StringType>
, <BoolType>
, and <PointerType>
.
Operands are numbers, returns number:
divide
, returning the value corresponding to val_x
divided by val_y
.
This is an integer division if and only if val_x
is an integer.minus
, returning the value corresponding to val_x
minus val_y
.plus
, returning the value corresponding to val_x
plus val_y
.power
, returning the value corresponding to val_x
to the power val_y
.times
, returning the value corresponding to val_x
times val_y
.Operands are <IntValue>
s, returns <IntValue>
:
modulo
, returning the value corresponding to val_x
modulo val_y
.Operands are <BoolValue>
s, returns <BoolValue>
:
and
, returning (BoolValue TRUE)
if both val_x
and val_y
are
(BoolValue TRUE)
, (BoolValue FALSE)
otherwise. Do not evaluate val_y
if
val_x
yielded (BoolBalue FALSE)
(lazy evaluation).not
, returning (BoolValue TRUE)
if val_x
is (BoolValue FALSE)
.
Otherwise, return (BoolValue FALSE)
.Operands are comparable, returns <BoolValue>
:
less_than
returning (BoolValue TRUE)
if val_x
is less than val_y
and
(BoolType FALSE)
otherwise. (BoolType FALSE)
is less than
(BoolType TRUE)
. <PointerValue>
s can be compared by comparing the strings
corresponding to having joined all elements in their respective string lists.Operands can be any type, returns <BoolValue>
:
equals
returns (BoolValue TRUE)
if val_x
has the same value as val_y
,
(BoolType FALSE)
otherwise. Be sure to compare values and not identity
(value vs reference).(relative_address <target: Computation> <extra: Computation>)
Appends to an address.
Parameters:
target
is a <Computation>
that will yield the base address to extend.extra
is a <Computation>
corresponding to the <StringValue>
element to
add to the address.Process:
<PointerValue>
corresponding to target
.<StringValue>
corresponding to extra
.<PointerValue>
corresponding to the previous <PointerValue>
,
but with its list of strings now having been extended by the addition of the
string equivalent to that <StringValue>
.(size <target: Computation>)
Computes the size of a list.
Parameters:
target
is a <Computation>
that will yield a <PointerValue>
pointing to
a <ListValue>
.Process:
<PointerValue>
yielded by target
.<IntValue>
corresponding to the number of elements in the
<ListValue>
pointed to by that <PointerValue>
.(text {values: <Computation> List})
Merges a list of text values into a single one.
Parameters:
values
is a list of <Computation>
s that will yield <TextValue>
s.Process:
<Value>
corresponding ot each element of values
.<TextValue>
corresponding to these <Values>
appended one
after the next.(value_of <target: Computation>)
Retries the value from memory.
Parameters:
target
is a <Computation>
that will yield the address of the memory
element to get the value of.Process:
target
.<Value>
pointed to by target
in the <State>
’s memory
.({extra_computation} {parameters: <Computation> List})
Performs non-standard computation.
Parameters:
extra_computation
is the name of the extra computation.parameters
is a list of parameters for this computation call.Process:
extra_computation
so that you can add non-standard computations.