Thube

To be constantly confused with Thubi.

This language is a derivative of Thue.

Thube (pronounced "TOO-bee") is a badly-named esoteric programming language and derivative of Thue designed by the Zodiac Working Group as an attempt to pull Thue out of the Turing Tarpit. It aims to implement high-level features into Thue like File Handling, libraries, and maybe a bit of OO.

This document is a Work In Progress.

Syntax

Thube uses a different syntax from traditional Thue. For starters, the entire format is different. Thube programs consist of a series of subprograms which consist of a name followed by an opening curly bracket, the subprogram, then a closing curly bracket.

<subprogram-name> {
    stuff;
    stuff;
    ...
    stuff;
}

The subprograms are:

• use: A list of libraries to use. Names separated by semicolons.
• objects: A series of objects created for usage later (such as sockets)
• rules: A series of rules dictating replacement strings.
• strings: Quoted strings separated by semicolons. The Thube interpreter executes the rules on these in sequence.

Rules in Thube go in the "rules" block and have a slightly different design. For starters, strings must be enclosed in single or double quotes (matching). These strings are operated on by either A) Putting them alone (for nonary) B) prefixing them with the operator (for unary) or C) putting them on either side of the operator (for binary). Operators are either single characters outside of strings OR multiple character contained in curly brackets (though single characters in curly brackets work just the same). Any characters can be an operator, which may be hard to implement in some languages.

A rule is defined by the following syntax

<base> ::= <replacement>;

Basically, the same as in normal Thue, but with a semicolon at the end.

Objects in Thube's objects block are defined as such:

<name> ::= <class>(*<comma-separated-args>);

Library Documentation

stdio

Operators:

"::": Replace with input. Save as replacement. Do not replace again. Return input.
":::": Get user input each time. Return input.
"~<string>": Print the following string. Return "".

fileio

Operators:

"^<fileNameString>": Open and read the following file. Return content.
"<string>_<fileNameString>": Write this string to this file. Return empty string.

socket

Objects:

socket(<address>, <port#>): Create a socket

Operators:

"^<socket>": Read this socket and return its contents
"<string>_<socket>": Write this string into this socket.

Examples

Hello World:

use {  # List of libraries to use
    stdio;  # Get the library for input and output
}  # End libraries

rules {  # Rules for replacement strings
    "a" ::= ~"Hello, world!";  # On the character "a", print "Hello, world!" to the console
}  # End rules

strings {  # List of strings to use
    "a";  # The string "a", the first (and only) base string
}  # End strings

Output the contents of a file (name hard-coded):

use {
    stdio;
    fileio;
}

rules {
    "a" ::= ~^"file.ext";  # Output (~) the contents (o) of file.ext
}

strings {
    "a"
}

Output the contents of a file by user input:

use {
    stdio;
    fileio;
}

rules {
    "a" ::= ~^{:::};  # Output (~) the contents (o) of a file from user input (:::)
}

strings {
    "a";
}

Cat server on port 666 (print output):

use {
    stdio;
    fileio;  # Sockets behave like files
    socket;
}

objects {
    sock ::= socket("", 666);
}

rules {
    "a" ::= ~^sock+sock_^sock;+"a"  # _ is the write operator from fileio. Neither ~ nor _ returns anything, but "a" returns "a", so it replaces it with itself, thus triggering an infinite loop
}

strings {
    "a";
}