| summaryrefslogtreecommitdiff |
diff options
Diffstat (limited to 'content/wyrd_v1/computation/_index.md')
| -rw-r--r-- | content/wyrd_v1/computation/_index.md | 125 |
1 files changed, 122 insertions, 3 deletions
diff --git a/content/wyrd_v1/computation/_index.md b/content/wyrd_v1/computation/_index.md index d0462a0..af00546 100644 --- a/content/wyrd_v1/computation/_index.md +++ b/content/wyrd_v1/computation/_index.md @@ -5,6 +5,7 @@ weight: 3 --- 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})`](#add_text_effect) @@ -103,77 +104,195 @@ The following conversions are expected to be available: ### constant `(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:** +* Parse the value of `value` according to `type`. +* Return the corresponding `<Value>`. + +**Notes:** +The `type` parameter can take the following values: `"string"`, `"float"`, + `"int"`, and `"bool"`. ### get_allocable_address `(get_allocable_address)` +Get an allocable address. + **Process:** +* Return an `<PointerValue>` corresponding to an unused address. + +**Notes:** +Process when using the suggested `<State>` definition: +* If the `<State>`'s `freed_addresses` collection has elements, return a +`<PointerValue>` corresponding to one of its elements. +* Otherwise, create a string `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 `(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:** +* Compute the `<BoolValue>` resulting from `condition`. +* Interpret this `<BoolValue>` as a `{Boolean}`. +* If it yielded `TRUE`, compute and return the `<Value>` resulting from + `if_true`, otherwise, compute and return the `<Value>` resulting from + `if_false`. ### last_choice_index `(last_choice_index)` +Get the index of the user's last chosen option. + **Process:** +* Return an `<IntValue>` corresponding to the `<State>`'s `last_choice_index`. ### newline `(newline)` +Return a newline value. + **Process:** +* Return a `<TextValue>` corresponding to a newline. ### Unary operation `(operation {operator: String} <x: Computation>)` -**Parameters:** - -**Process:** +Interpret as `(operation operator x (BoolValue FALSE))`. It is recommended to +have the parser do that conversion automatically. ### operation `(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:** +* Compute `<val_x: Value>` and `<val_y: Value>`, the `<Values>` corresponding to + `x` and `y`, respectively. +* See the *Notes* below for which operators are expected. +* Return the result of the operation. + +**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 `(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:** +* Compute the `<PointerValue>` corresponding to `target`. +* Compute the `<StringValue>` corresponding to `extra`. +* Return a new `<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 `(size <target: Computation>)` +Computes the size of a list. + **Parameters:** +* `target` is a `<Computation>` that will yield a `<PointerValue>` pointing to + a `<ListValue>`. **Process:** +* Compute the `<PointerValue>` yielded by `target`. +* Return a new `<IntValue>` corresponding to the number of elements in the + `<ListValue>` pointed to by that `<PointerValue>`. ### text `(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:** +* Compute the `<Value>` corresponding ot each element of `values`. +* Return a new `<TextValue>` corresponding to these `<Values>` appended one + after the next. ### value_of `(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:** +* Compute the value of `target`. +* Return the `<Value>` pointed to by `target` in the `<State>`'s `memory`. ### extra_computation `({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:** +* Undetermined. This is where you choose the process according to the value of + `extra_computation` so that you can add non-standard computations. |