History: samtrosku specification

Source of version: 2 (current)

la samtrosku xi no pi'e pa pe fi'e la ((rab.spir)) __samtrosku__ is a procedural computer language expressed in Lojban. ((samtrosku examples)) A samtrosku program must parse. Certainly some parts of the language could be simplified for computers - for example, names wouldn't necessarily have to be pronounceable - but samtrosku's unique advantage is that it could be spoken aloud. The commands and functions in samtrosku are brivla, and are defined by their place structure. !!Statements and blocks A statement is a bridi. A statement can be a simple bridi such as {li abu mleca li ci}. This simply returns a truth value of "true" or "false", which can be used if the next statement is connected with a logical connective, or if the statement is part of a function. A statement can also be a bridi involving {ko}. This is a command for the computer to do something, such as {ko cusku lu coi munje li'u}. It returns "true" if the command can be performed, and "false" otherwise. Because of the way truth values work, {ko} is always equivalent to {do}. If a statement is connected to another statement with a logical connective, the first statement is performed, and then the second statement is either performed or skipped in order to make the connective true. If the connective would be true (or false) either way, the second statement is skipped - call this the "laziness rule". The text scope containing both statements is assigned a truth value - if the connective cannot be made true, the truth value of the connected statements is false; otherwise it is true. If the end of a text scope is reached (there are no more connectives, and the commands are not inside a block) and the last truth value is "false", the program stops with an error. So a command which cannot be executed will stop the program. Also, this means a simple statement, not connected to anything, can be used as an assertion - if it is true, nothing happens, and if it is false, the program stops. !!!Blocks A block is a set of statements grouped with {tu'e ... tu'u}. It creates a separate text scope, which is true if all the statements within are true, and false otherwise (at which point no more statements in the block are executed). Unlike a logical connective scope, a block does not overwrite {go'u} and {go'a} (see below). The cmavo {di'e} would refer to whatever is in the following text scope (but must be used as {la'edi'e} to actually run the code). So {di'e} would most commonly be used to introduce a block. Blocks are useful for defining loops and brivla. !!!Recent truth values If you want to do something with logical values that connectives cannot handle (such as an if-then-else statement), you can use the go'V series of cmavo. * go'i contains the most recent truth value. * go'e contains the second most recent truth value. * go'u contains the truth value of the first part of the most recent logical connective. * go'a contains the truth value of the second part of the most recent logical connective. So if you want the program to execute {ko brode} if {broda} is true, and {ko brodi} if not, you could do this: broda .ijo ko brode .i go'u ijonai ko brodi (By using the 'experimental cmavo' feature described later, you could reduce {.i go'u ijonai} to {.ijo'ai} for convenience.) !!Variables The ko'a-series, {la} followed by a name, or any sequence of lerfu can refer to a value. Variables defined outside of a function are global. Variables can also be explicitly made global with the brivla {vitno} (as in {ko'a vitno}). To access a global variable inside a function, follow it with {bi'unai} when it first appears. {bi'u} can also be used to explicitly state that a variable is local. !!!Assignment Assignment of variables can be done with {goi}, {dubgau}, or {dungau}, which have different effects. {goi} performs the action called "unification": if the variable on one side is assigned and the variable on the other side is not, it makes the unassigned variable equal to the assigned one. If both variables are already assigned, then the statement containing {goi} fails. If one variable is cleared with {da'o}, the other continues to exist. Both variables are then given the same referent - this happens even if both variables were equal, or both variables were unassigned. So after unification, the variables are linked so that one changes when the other does. This can be used to give more useful names to items of a sequence, or to give a variable a lerfu-based name so it can be used in a mekso expression. {dungau} takes three arguments: __dungau__: x1 (ko) sets the value of x2 (variable) equal to that of x3 (variable) The referent of the variable in x2 is not changed, so one can be assigned again later without affecting the other. This is the standard form of assignment in most programming languages. {dubgau} takes any number of arguments after the first which is {ko}. Every argument starting at x2 is given the same referent as the rightmost argument. !!Defining brivla Brivla are defined using logically linked statements, with {ca'e} at the beginning of the bridi that is being defined. The connective should usually be 'o' or 'onai', but 'a' would work like 'onai' because of the laziness rule. So a brivla could be defined using these general structures: go ca'e <bridi being defined> gi <statement> go ca'e <bridi being defined> gi ko zukte la'edi'e .i <block> ko ca'e <bridi-tail being defined> gi'o <bridi-tail> (defines simple commands) ca'e <bridi being defined> ijo <statement or block> This last form is the one which is most likely to be useful for complex definitions. !!!Truth tests If all the places are known and none are {ko}, the brivla is a truth test, which is true if the defining statement or block is true, and false otherwise. Example: This brivla tests whether x1 is between the items in the two-item sequence x2. ca'e ko'a jbini ko'e ijo | (defining "x1 is between x2"): tu'e | by goi le pamoi be ko'e | (b = ko'e((1))) .i cy goi le remoi be ko'e | (c = ko'e((2))) .i ge ko'a zmadu by gi ko'a mleca cy | (is it true that b < ko'a < c?) tu'u With this brivla defined: .i li 3 jbini li 2 ce'o 4 | (returns true) .ijo ko cusku lu go'i li'u | (prints "go'i") .i go'i ijonai ko cusku lu na go'i li'u | (otherwise print "na go'i") !!!Functions A function is like a truth test, but one of its places (usually the x1) is unknown. The result is returned as that place, using the predicate {jagdu'o}. __jagdu'o__: x1, as a result, is equal to x2 If x1 is unknown, {jagdu'o} sets x1 equal to x2. If x1 is known, {jagdu'o} does nothing, but has a truth value of whether x1 equals x2. This means that a function can be used as a truth test. The result of a function is retrieved with {le}. Example: This brivla can either return the square of x2 in x1, or test whether x1 equals x2 squared. ca'e ko'a kurpi'i by ijo ko'a jagdu'o li by pi'i by With this brivla defined: ko cusku le kurpi'i be li 3 | (prints "9") .i li 16 kurpi'i li 4 | (returns true) .ijo ko cusku lu go'i li'u | (prints "go'i") !!!Commands A command is a truth test or a function which performs an action. This could be accomplished simply with {ko} statements in the block, but it is good form to fix {ko} as the x1 by putting it in the x1 of the {ca'e} phrase. Hence, the definition of a command {ganzu} which takes one argument {ko'a} would look like this: ca'e ko ganzu ko'a ijo tu'e ... tu'u Then this command would be called with {ko ganzu ...}, and if the {ko} were not there (for example, if something tried to refer to {le ganzu}, which makes little sense), the command would fail. !!!Loops A "while" loop would be done in this form: .i ca le du'u <statement1> kei <statement2> ...which says to repeatedly perform <statement2> while <statement1> is true. Of course, this could always be rephrased as .i <statement2> ca le du'u <statement1> Also, <statement2> would very frequently be a block. !!!Case statements Case statements would be begun by asking the computer a question; it would then return a Lojban string containing the answer to that question. I'm not certain yet how the choices would be given from there. !!Strings !!!Literal strings and filenames Pure strings are quoted with {zoi}; filenames are quoted with {la'o}. The ordinary delimiters should be usable in most cases, though I suggest that the angle bracket convention (using < and > to delimit the quoted text) should be usable as well. The quoted string would be whatever is between the delimiters, not counting the whitespace on each end. These strings would be the only part of samtrosku that is not speakable. If the string is a particularly pathological one, you may use a mekso of lerfu (example: "hi^Z ", where ^Z is character code 1A and the string ends with a space, could be {lu'e me'o y'ybu ibu se'e pa dau na'a denpa bu}. Character codes should be hexadecimal. In C they are octal, but this is because the letters A-F would create ambiguity if they appeared in a character code embedded in a string. In samtrosku there is no such problem. ((Obligatory troll-protective disclaimer: This does not mean that I endorse using hexadecimal "by default" in the rest of the language, either lojban or samtrosku.)) !!!Lojban strings Text enclosed in {lo'u...le'u} is a string composed of Lojban words. The literal text is not used; the text is stored as the Lojban words it represents. So {ko cusku lo'u icale nubroda le'u} could display ".i ca le nu broda". !!Input and output Besides the fact that {cusku} would write to standard output, I haven't yet decided anything here. !!Loading brivla definitions The definition of a brivla can be loaded from another file. A brivla is defined using {cilre}. __cilre__: x1 (ko) learns the instructions corresponding to x3 (gismu/lujvo/fu'ivla) from x4 (file) x2 and x5 are ignored, though they might mean something in a later revision of samtrosku. If x3 is {zo'e} it learns every brivla in that file; if x4 is {zo'e} an implementation may search a standard path to find the appropriate brivla. Examples: ko cilre fi zo cunyna'u ko cilre fi zo pandi la'o < /usr/share/samtrosku/brivla/vrici.sam > ko cilre fo la'o < /usr/share/samtrosku/brivla/kanji.sam > !!Defining experimental cmavo A cmavo is defined in experimental cmavo space by setting it equal to a fragment of text, using the predicate {cmavygau}. __cmavygau__: x1 (ko) defines x2 (cmavo) to represent x4 (text fragment) x3 (the selma'o) and x5 (samtrosku) are ignored. For example: .i ko cmavygau zo lai'e fi | makes "la'edi'e" shorter lo'u la'e di'e le'u .i ko cmavygau zo jo'ai fi | makes a pseudo-connective for "if-then-else" lo'u go'u ijonai le'u !!sumti types Samtrosku is weakly typed, and inherently to the semantics of Lojban, there are lots of types. Only certain types work in certain situations. Here is a list of types and examples of how each might be referred to (these references could then be assigned to a variable such as {ko'a} using {goi}.) * personal: {ko}, {do} * number: {li 3} ** floating-point number: {li 3pi2}, {li 4pi}, {li pai} ** mixed-base number: {le tcika} ** Boolean value: {le jei go'i} ** complex number: {li ci ka'o re} * ratio: {li 4 pa'i 2} * interval: {li no bi'o pano}, {li su'o 2} * vector: {li jo'i 1 boi 2 te'u} * matrix: {li jo'i 1 boi 0 te'u pi'a jo'i 0 boi 1 te'u} * set: {li 2 ce li 4}, {lu'i ko'i} * sequence: {li 2 ce'o li 4}, {vu'i ko'i} * unevaluated expression: {me'o by pi'i by} * character: {lu'e me'o by}, {lu'e me'o se'e 62}, {zoi <b>} * string: {zoi <xyzzy>} ** parseable string, unevaluated code: {lu na go'i li'u}, {di'e} ** evaluated code: {la'edi'e} ** words: {lo'u go'u ijonai le'u}, {zo lai'e} ''For a better list of types, look through the gismu list. Some places are specified for ka, others for du'u, some for sets and others for numbers. These are some Lojban datatypes.''