HGFTSNOA

HGFTSNOA is an esoteric programming language created by User:PythonshellDebugwindow.
==Keywords==
HGFTSNOA uses eight keywords. Each keyword has a normal identifier and a wimpmode identifier. Valid HGFTSNOA programs can only contain normal identifiers.
Normal 	Meaning/Usage 	Wimpmode
T 	Begin function body 	HELLO
TT 	End function body 	GOODBYE
TTT 	Begin if statement 	IF
TTTT 	Returning from functions; string indexing 	IT
TTTTT 	Function declarations; assignment; equality	IS
TTTTTT 	End if statement 	THEN
TTTTTTT 	Begin else branch 	OR
TTTTTTTT	Addition; string concatenation 	AND
These keywords are the origin of the name HGFTSNOA: each of its letters is derived from a key letter (e.g. H for HELLO, N for THEN) of each keyword's wimpmode identifier in order.
==Character set==
HGFTSNOA uses the following 16 characters: Tt0123456789"-(space)(newline). No other character can occur in a valid HGFTSNOA program.
==Datatypes==
HGFTSNOA uses two datatypes. Integers are unbounded integers, while strings are strings of arbitrary length.
Datatype	Regex 	Example
Integer 	[0-9]+	123
String 	".*?" 	"Tt123"
There are no escape codes in HGFTSNOA strings; as such, they can only contain 15 characters (HGFTSNOA's 16 characters minus the double quote ", which cannot be escaped) without using the string expansion operator -.
==Syntax==
===Main function===
The nameless "main" function is the program's entry point. It cannot be called by any function within the program. Its statements are located between the T and TT keywords:
 T
 ...
 TT
The main function must be defined exactly once in every program.
===Function declaration===
To declare a function called fname which takes no arguments, the following syntax is used:
 fname TTTTT T
 ...
 TT
fname must consist of the lowercase letter t repeated one or more times. Multiple functions cannot have the same name.
Function declarations cannot be nested.
===Function arguments and returning===
When declaring a function, arguments are placed between the TTTTT and T keywords. For example, the following function takes two arguments (and does absolutely nothing):
 t TTTTT tt ttt T
 TT
The TTTT keyword can be used to return a value from within a function. As an example, the following function takes two arguments (ttt and tttt) and returns their sum. It first adds ttt and tttt using the TTTTTTTT keyword, and then returns the calculated value.
 t TTTTT ttt tttt T
 TTTT ttt TTTTTTTT tttt
 TT
Function calls use Polish notation: the name of the function being called precedes its arguments. As an example, the following function takes four arguments and uses the t function (defined in the previous example) to calculate their sum:
 tt TTTTT ttt tttt ttttt tttttt T
 TTTT t t ttt tttt t ttttt tttttt
 TT
It first adds its first two arguments, then its second two, and then returns the sum of those two sums.
The main function can return a value, but the returned value will be ignored.
===Assignment===
To set the variable vname to the value value, the following syntax is used:
 vname TTTTT value
Like the name of a function, vname must consist of the lowercase letter t repeated one or more times. The name of a variable or function parameter cannot be the same as that of a function. Variables and function parameters are not constant, and can be assigned new values after being initialised. Attempting to reference an undefined variable will cause a runtime error.
===If statements===
To create an if statement whose condition is value, the following syntax is used:
 TTT value
 code if true...
 TTTTTT
The keyword TTTTTTT can be used to specify an "else" branch:
 TTT value
 code if true...
 TTTTTTT
 code if false...
 TTTTTT
An if statement will run if and only if its condition is truthy, i.e. not equal to the empty string or 0. If an "else" branch is provided, it will be executed only if the statement's condition was not truthy.
==Operators==
There are 4 operators in HGFTSNOA: - (minus), TTTT (IT), TTTTT (IS), and TTTTTTTT (AND). They all have the same precedence and are evaluated from left to right. Function calls have a lower precedence, so that 1 TTTTTTTT tt 2 3 4 TTTTTTTT 5 would in many languages be 1 + tt(2, 3, 4 + 5).
===Minus operator===
The unary - operator performs two functions: negation and string expansion.
With an integer operand, - is the negation operator. It subtracts its operand from zero and evaluates to the result.
With a string operand, - is the expansion operator. It performs string expansion on its operand and evaluates to the result; see #String expansion for more information.
===IT operator===
TTTT also serves two functions. As mentioned earlier, it allows functions to return a value; when between two values, however, it is instead the binary indexing operator.
The indexing operator requires a string as its left operand and an integer as its right operand. If its operands are not of the right type, an error will be raised. The operator performs string indexing using its operands and evaluates to the result; see #String indexing for more information.
TTTT will be parsed as a return statement when it is after one of the keywords T, TTTTTTT, and TTTTTT; in all other cases, it will be parsed as the indexing operator.
===IS operator===
When not used for assignment, the TTTTT operator is the binary equality operator. It returns 1 if and only if its two operands have the same type and value; otherwise, it returns 0.
TTTTT will only be evaluated as the assignment operator if all of the following conditions are true:
* It is the second token in its expression.
* Its left operand is an identifier.
* It is not in the condition of an if statement.
* It is not in an argument in a function call.
* It is not part of a return statement.
Otherwise, it will be evaluated as the equality operator.
===AND operator===
The TTTTTTTT operator serves two functions: addition and concatenation.
With an integer as its left operand, TTTTTTTT is the binary addition operator. It evaluates to the sum of its left operand and its right operand. If its right operand is a string, it is converted to an integer; if it is not a valid integer (at least one of its characters is not one of the digits 0-9), it will be treated as zero.
With a string as its left operand, TTTTTTTT is the binary concatenation operator. It concatenates its right operand to its left operand and returns the result. If its right operand is an integer, it is converted to a string before being concatenated.
==String indexing==
TTTT can function as the string indexing operator. Given a string S as its LHS and an integer N as its RHS, the operator evaluates to the (0-based) Nth character of S. If N is negative, then the operator will instead evaluate to the (1-based) Nth character from the end of the string. If N is out of bounds, the operator will evaluate to the empty string.
For example, the following program:
 T
 "0123456789" TTTT 7
 "12345" TTTT -2
 TT
will print:
 7
 4
==String expansion==
If the operand of the - operator is a string, the operator will perform string expansion. This means that it will evaluate to a version of the string in which all keywords are replaced with their wimpmode equivalents, and all variables are replaced with their values.
For example, the following program:
 T
 t TTTTT 123
 -"T t"
 -"Tt"
 -"T" TTTTTTTT " t"
 tt TTTTT "T" TTTTTTTT " t"
 -tt
 TT
will print:
 HELLO 123
 HELLO123
 HELLO t
 HELLO 123
String expansion is performed from left to right, and longer keywords and variable names are replaced before shorter ones. This means that the following program:
 T
 tttt TTTTT 42
 -"ttttttt"
 t TTTTT "5"
 -"ttttttt"
 -"TTTTTTTTT"
 TT
will print:
 42ttt
 42555
 ANDHELLO
Expansion is not recursive. For example, the following program will print tt and not 2:
 T
 tttt TTTTT "ttt"
 ttt TTTTT "tt"
 tt TTTTT "2"
 -tttt
 TT
String expansion is the only way to output letters other than T and t. It allows you to output the letters A, B, D, E, F, G, H, I, L, N, O, R, S, and Y.
==Scope==
All functions are available at all places in the program; the sole exception to this is the main function, which is nameless and thus cannot be called in the program. By contrast, variables and function parameters are not subject to any "global scope", and they are only available in the function in which they were defined.
For example, the following program will output the number 123:
 T
 t TTTTT 123
 tt
 t
 TT
 tt TTTTT T
 t TTTTT 456
 TT
And the following program will raise an error, since the variable t is not available within tt:
 T
 t TTTTT 42
 tt
 TT
 tt TTTTT T
 t
 TT
==Input and output==
Output in HGFTSNOA is implicit. All values which are not used in expressions or returned by functions are automatically output, followed by a newline.
There is no way to request user input in HGFTSNOA.
==Examples==
===HELLO GLOBE===
The letter W cannot be output, nor can any lowercase letters; as a result, this is pretty much the closest HGFTSNOA can come to the classic "Hello, world!" program.
 T
 t TTTTT -"TT" TTTT 0
 tt TTTTT -"T" TTTT 2
 ttt TTTTT -"TTTTTTT" TTTT 0
 tttt TTTTT -"TT" TTTT 4
 ttttt TTTTT -"T" TTTT 1
 -"T " TTTTTTTT t TTTTTTTT tt TTTTTTTT ttt TTTTTTTT tttt TTTTTTTT ttttt
 TT
===Truth-machine===
Initialise the variable t to 0 or 1 as appropriate.
 T
 t TTTTT (0 or 1)
 TTT t TTTTT 1
 tt
 TTTTTTT
 0
 TTTTTT
 TT
 tt TTTTT T
 1
 tt
 TT
===Output all characters of a string separately===
The string in question is located on the second line.
 T
 t TTTTT "0123456789T-t"
 tt 0 t
 TT
 tt TTTTT ttt t T
 tttt TTTTT t TTTT ttt
 TTT tttt TTTTT ""
 TTTTTTT
 tttt
 tt ttt TTTTTTTT 1 t
 TTTTTT
 TT
===Fibonacci sequence===
This program outputs the first 15 Fibonacci numbers. The number of numbers can be adjusted by adjusting the number on the second line.
 T
 tt 15
 TT
 
 tt TTTTT t T
 ttttttt 0 t 0 1
 TT
 
 ttttttt TTTTT ttt tttt ttttt tttttt T
 TTT ttt TTTTT tttt
 TTTTTTT
 ttttt
 ttttttt ttt TTTTTTTT 1 tttt ttttt TTTTTTTT tttttt ttttt
 TTTTTT
 TT
===Ackermann function===
The inputs to the function are the two numbers on the second line.
T
 t 4 0
TT
t TTTTT tt ttt T
 TTT tt TTTTT 0
 TTT 0 TTTTTT
 TTTT ttt TTTTTTTT 1
 TTTTTT
 TTT ttt TTTTT 0
 TTT 0 TTTTTT
 TTTT t tt TTTTTTTT -1 1
 TTTTTT
 TTTT t tt TTTTTTTT -1 t tt ttt TTTTTTTT -1
TT
===Digital root calculator===
The number whose digital root is to be calculated is on the second line.
T
 t "" TTTTTTTT 34758
TT
t TTTTT tttt T
 tttt TTTTT "" TTTTTTTT tt tttt 0 0
 TTT tttt TTTT 1
 t tttt
 TTTTTTT
 0 TTTTTTTT tttt
 TTTTTT
TT
tt TTTTT tttt ttttt tttttt T
 TTT tttt TTTT ttttt
 ttttttt TTTTT tttt TTTT ttttt
 TTT 0 TTTTTT
 TTTT tt tttt ttttt TTTTTTTT 1 tttttt TTTTTTTT ttttttt
 TTTTTTT
 TTTT tttttt
 TTTTTT
TT
===Factorial calculator===
This program calculates the factorial of the number on the second line.
T
 t 30
TT
t TTTTT ttt T
 TTT ttt TTTTT 0
 0
 TTTTTTT
 ttttttt ttt 1 1
 TTTTTT
TT
ttttttt TTTTT ttt tttt ttttt T
 TTT ttt TTTTT tttt
 TTT 0 TTTTTT
 TTTT tt ttttt tttt 0 0
 TTTTTTT
 TTTT ttttttt ttt tttt TTTTTTTT 1 tt ttttt tttt 0 0
 TTTTTT
TT
tt TTTTT ttt tttt ttttt tttttt T
 TTT ttttt TTTTT tttt
 TTT 0 TTTTTT
 TTTT tttttt
 TTTTTTT
 TTTT tt ttt tttt ttttt TTTTTTTT 1 tttttt TTTTTTTT ttt
 TTTTTT
TT
===FISSBOSS===
HGFTSNOA cannot output the letters U or Z.
T
 tt TTTTT -"TTTTT" TTTT 1
 ttt TTTTT -"TTT" TTTT 1 TTTTTTTT -"TTTTTtt"
 tttt TTTTT -"T" TTTT 4 TTTTTTTT tt TTTTTTTT tt
 tttt TTTTT -"TT" TTTT 4 TTTTTTTT tttt
 t 1 100 1 1 ttt tttt
TT
t TTTTT tt ttt tttt ttttt tttttt ttttttt T
 TTT tttt TTTTT 3
 TTT ttttt TTTTT 5
 tttttt TTTTTTTT ttttttt
 ttttt TTTTT 0
 TTTTTTT
 tttttt
 TTTTTT
 tttt TTTTT 0
 TTTTTTT
 TTT ttttt TTTTT 5
 ttttttt
 ttttt TTTTT 0
 TTTTTTT
 tt
 TTTTTT
 TTTTTT
 TTT tt TTTTT ttt TTTTT 0
 t tt TTTTTTTT 1 ttt tttt TTTTTTTT 1 ttttt TTTTTTTT 1 tttttt ttttttt
 TTTTTT
TT
===99 BOTTLES OF BEER ON THE FLOOR===
Again, HGFTSNOA can only output certain letters. The following program attempts to work around this limitation while staying as close to the original song as possible.
T
 tttttttttttttttttttt 99
TT
tttttttttttttttttttt TTTTT tt T
 tttttt TTTTT -"T" TTTT 4
 ttttttt TTTTT -"T" TTTT 1
 ttttt TTTTT -"TT" TTTT 4
 tttt TTTTT -"ttttttTTTTTTT"
 tttt TTTTT -"T" TTTT 2 TTTTTTTT tttt
 tttt TTTTT -"TTT" TTTT 1 TTTTTTTT tttt
 tttt TTTTT -"TTTTTT" TTTT 2 TTTTTTTT " " TTTTTTTT tttt
 tttt TTTTT -"T" TTTT 0 TTTTTTTT tttt
 tttt TTTTT -"TTTT" TTTT 1 TTTTTTTT tttt
 tttt TTTTT -"TTTTTT" TTTT 3 TTTTTTTT -" tttt"
 tttt TTTTT -" tttttt" TTTTTTTT tttt
 ttt TTTTT -"TTTTTTT" TTTT 1
 ttt TTTTT ttttt TTTTTTTT ttttttt TTTTTTTT ttttttt TTTTTTTT ttt
 ttt TTTTT -"TTT" TTTT 1 TTTTTTTT -" ttt"
 ttt TTTTT " " TTTTTTTT tttttt TTTTTTTT ttt
 tttttttttt TTTTT -"T" TTTT 2 TTTTTTTT ttttttt
 t TTTTT -"TTTT" TTTT 1
 tttttttttt TTTTT t TTTTTTTT t TTTTTTTT tttttttttt
 tttttttttt TTTTT tttttt TTTTTTTT tttttttttt
 tttttttttt TTTTT -" ttttt" TTTTTTTT tttttttttt
 TTT tt TTTTT 1
 ttttttttttttttt TTTTT ttt TTTTTTTT tttt
 tttttttt TTTTT tttttttttt TTTTTTTT ttt TTTTTTTT tttt
 TTTTTTT
 ttttttttttttttttt TTTTT ttt TTTTTTTT tttt
 ttttttttttttttttt TTTTT tttttttttt TTTTTTTT ttttttttttttttttt
 tttttttttttttttt TTTTT ttt TTTTTTTT tttt
 tttttttt TTTTT -"TTTTT" TTTT 1 TTTTTTTT tttttttttttttttt
 tttttttt TTTTT tttttttttt TTTTTTTT tttttttt
 TTTTTT
 -"tt" TTTTTTTT tttttttt TTTTTTTT " -"
 TTT tt TTTTT 1
 -"tt" TTTTTTTT tttttttttt TTTTTTTT ttt
 TTTTTTT
 ttttttttttt TTTTT -"TTTTT" TTTT 1
 -"tt" TTTTTTTT tttttttttt TTTTTTTT ttttttttttt TTTTTTTT ttt
 TTTTTT
 tttt TTTTT -"TTT" TTTT 1
 ttt TTTTT -"TTTTTTT" TTTT 1 TTTTTTTT -" TTTT" TTTTTTTT " -"
 ttt TTTTT tttt TTTTTTTT ttttttt TTTTTTTT ttt
 ttt TTTTT -"TTTTT" TTTT 1 TTTTTTTT ttt
 ttt TTTTT -"TTTTTT" TTTT 3 TTTTTTTT ttt
 ttt TTTTT -"TTTTTTTT" TTTT 0 TTTTTTTT ttt
 ttt TTTTT -"TTTTTTT" TTTT 1 TTTTTTTT ttt
 ttt TTTTT -"TTTT" TTTT 1 TTTTTTTT ttt
 ttt TTTTT tttttt TTTTTTTT tttt TTTTTTTT -"tttt - " TTTTTTTT ttt
 ttt TTTTT -"TTTTTT" TTTT 3 TTTTTTTT -"ttttttt ttt"
 ttt TTTTT -"TTTT" TTTT 1 TTTTTTTT -" tttttt" TTTTTTTT ttt
 ttt TTTTT -"T" TTTT 2 TTTTTTTT -"TTTttt"
 ttt
 tt TTTTT tt TTTTTTTT -1
 TTT tt
 TTT tt TTTTT 1
 "1" TTTTTTTT ttttttttttttttttt
 TTTTTTT
 -"tt" TTTTTTTT tttttttt
 TTTTTT
 ""
 tttttttttttttttttttt tt
 TTTTTTT
 ttttttttttttttt TTTTT -"TTTTT" TTTT 1 TTTTTTTT ttttttttttttttt
 ttttttttttttttt TTTTT tttttttttt TTTTTTTT ttttttttttttttt
 -"TTTTTT" TTTT 3 TTTTTTTT tttttt TTTTTTTT ttttttttttttttt
 TTTTTT
TT
==Computational class==
HGFTSNOA is Turing-complete, as it can interpret a Turing-complete variation of brainfuck. See HGFTSNOA/Turing-Completeness proof for more details.
==External resources==
* An interpreter written in Node.js
Category:Languages Category:2020 Category:Implemented Category:Turing complete Category:Output only