Forobj

Forobj is an object oriented programming language created by User:Fergusq. It is designed to be easily extendable and almost impossible to parse without interpreting.
== Overview ==
Forobj is a stack-based language. A program is a list of commands and values. Values are pushed to the stack as commands are executed. Techically, values are commands.
 "This is a string value and is pushed to the stack."
 d
 "'d' is a command which pops and prints a string."
 d
The interpreter parses and executes at the same time. Command syntaxes can be edited runtime. Control flow is done by editing input queue.
Forobj is statically typed, which means that a variable can have only one type. Whitespace is not allowed between command arguments.
== Input queue ==
Forobj code is translated into an input queue at the begin of interpretation. The input queue contains characters. The interpreter reads those characters and creates tokens from them following command syntax. A string, for example, is a token.
When a function is called, interpreter creates a new input queue from function's code and executes it.
=== Editing input queue ===
There are two commands used to modify the input queue. \ appends code to it, and ; removes it.
A loop can be done using these commands.
 [, code condition;\],._%
First, a function (a string) is pushed to the stack and duplicated. Then it is called and intepreteted in the same stack (_). In the function, the function itself is first duplicated (,). At the end of the function, an input queue is conditionally cleared if a condition is true (clearing input queue exits from the function). If condition is false, the code of the function is appended to the input queue (\).
== Control Flow ==
Basic if:
 [
 	then
 ][
 	else
 ]condition?
While loop, code must not leave elements to the stack.
 [,
 	code
 condition;\],._%
== Functions ==
Defining a function:
 [>argI >argII >argIII
 	code
 ]>name
For example:
 [>name
 	"Hello, "d $name d "!\n"d
 ]>sayHello
Calling a function:
 $name.argument_count
Example:
 "John" $sayHello.1
== Classes and objects ==
Creating a class:
 ~car<$speed>
 [>self "Driving... Speed: "d $self:$speed d "\n"d ] ~car<drive:0>
Fields do not need to be declared, but they should, as if not, they are initiated with an undefined value and throw an error if are being accessed.
Using class:
 ^car >mycar
 $mycar:drive
Fields can be used to create a hash map:
 [ ""@+ ]#s_
 [>self>value>name $value\ [$self:>a]\ $name s\] ~map<set:2>
 [>self>name [$self:$a]\ $name s\] ~map<get:1>
 
 ^map >m
 "value" "key" $m:set
 "key" $m:get d
== Commands ==
Characters c (character), i (identifier) and n (number) represent command arguments. Commands can have many syntaxes.
=== Values ===
Command Character	Command syntax	Stack After	Name 	Description
" 	"c*" 	s 	String 	Creates a new string and pushes it to the stack.
[ 	[([?c*[?)*] 	s 	Nested String	Used for function body declarations
' 	'n 	n 	Number 	Pushes a number to the stack
^ 	^i 	obj 	Object 	Creates a new object. Argument is the class name.
=== Commands and classes ===
Command Character	Command syntax	Stack Before	Stack After	Name 	Description
@ 	@c 	? 	? 	Original Command 	Executes the original command. Usable if a command is overwritten.
# 	#cn#c_ 	string 	 	Command Declaration	Defines a new command. Argument is the parameter count. Semantics similar to the method declaration and function calling.
< 	<[cnis]<ac 	 	token_value	Read Token 	Reads a token from the parent input queue. Used for reading command arguments. c is a character, n is a number, i is an identifier and s is a whitespace. This can also accept a character, throwing syntax error if it doesn't match.
~ 	~i<i:n>~i<i:_>	string 	 	Method Declaration 	Defines a new method. Class name is the first argument. Between < and > are the method name and the argument count. Semantics similar to the command declaration.
~ 	~i<$i> 	 	 	Field Declaration 	Defines a new field. Class name is the first argument.
=== Functions and object access ===
Command Character	Command syntax	Stack Before 	Stack After 	Name 	Description
. 	.n._ 	args function 	return_value	Function call 	Calls a function with n arguments. Function is a string. If argument number is not specified (_), uses the main stack. Otherwise creates a new stack and pushes arguments into it. Return value is popped from functions stack (if not empy).
? 	? 	then else condition	 	Conditional Function Call	Calls then function if condition is not 0, otherwise the else function. No new stacks are created.
: 	:i 	args object 	return_value	Object Method Call 	Calls a method. Semantics similar to the function call, except that the object is pushed to function's new stack.
: 	:$i 	object 	field_value 	Object Field Load 	Pushes the value of a field to the stack.
: 	:>i 	value object 	 	Object Field Store 	Stores a value to the field.
=== Variables ===
Variables are similar to fields. Variables belong to a stack. If a new stack is created (when function is called), it contains it's own variable scope.
Command Character	Command syntax	Stack Before	Stack After	Name 	Description
$ 	$i 	 	var_value 	Variable Load 	Pushes the value of a variable to the stack.
> 	>i 	value 	 	Variable Store	Stores a value to a variable.
=== Input Queue ===
Every string has it's own input queue. When the program starts, the whole program loaded into an input queue. When a string is executed as a function, it is loaded into a new input queue.
Command Character	Command syntax	Stack Before	Name 	Description
\ 	\ 	string 	Input Queue Add 	Adds a string to the end of the input queue.
; 	; 	condition 	Input Queue Delete	Deletes the input queue if the condition is not 0, exits from the current input queue.
=== Stack ===
Command Character	Command syntax	Stack Before	Stack After	Name 	Description
, 	, 	a 	a a 	Stack Duplicate	Duplicates the top element of the stack.
½ 	½ 	a b 	b a 	Stack Swap 	Exchanges the top elements of the stack.
% 	% 	a 	 	Stack Pop 	Removes the top element of the stack.
=== Math ===
Command Character	Command syntax	Stack Before	Stack After	Name 	Description
+ 	+ 	a b 	a+b 	Add 	Adds two numbers or concatenates two strings.
- 	- 	a b 	a-b 	Subtract	Subtracts a number from another.
* 	* 	a b 	a*b 	Multiply	Multiplies two numbers.
/ 	/ 	a b 	a/b 	Division	Divides a number by another.
_ 	_ 	a 	-a 	Negation	Negates a number.
=== Logic ===
Command Character	Command syntax	Stack Before	Stack After	Name 	Description
= 	= 	a b 	a=b 	Equals	1 if equal, otherwise 0.
& 	& 	a b 	a&b 	And 	1 if neither a or b is 0, otherwise 0.
¦ 	¦ 	a b 	a¦b 	Or 	1 if a or b is 1, otherwise 0.
! 	! 	a 	!a 	Not 	1 if a is 0, otherwise 0.
=== I/O ===
Command Character	Command syntax	Stack Before	Stack After	Name 	Description
d 	d 	msg 	 	Default Out 	Print's a string to the default output stream.
n 	n 	 	char 	Default In Next Character	Reads a character from the default input stream.
== Examples ==
=== Hello world ===
 "Hello World\n"d
=== Fibonacci sequence ===
 ["\n"d]#l_
 
 '0 >a
 '1 >b
 '0 >c
 '10 >i
 
 [,
 	$a $b +	>c
 	$b >a
 	$c >b
 	
 	'11$i-d	":"d $a dl
 	
 	$i '1 - >i
 	$i!; \
 ],._%
Short version:
 ',>a>c'1>b'10>i[,$b,$a+,>c$b>a>b$a d"\n"d$i'1-,>i!; \],._%
=== Truth-machine ===
 n>n["0"d][[,"1"d\],[]$n"1"=?]$n"0"=?
=== Command example ===
 ["\n"d]#l_
 [
 	<n>id
 	<s
 	<a-
 	<s
 	<i>name
 	
 	"<b>§"d $id d "</b> - <i>"d $name d "</i>"dl
 ]#§0
 
 §1 - Introduction
 §2 - Body
 §3 - FinalWords
Outputs:
 <b>§1</b> - <i>Introduction</i>
 <b>§2</b> - <i>Body</i>
 <b>§3</b> - <i>FinalWords</i>
=== Deadfish interpreter ===
 ">> "d'>i[,n>c[$i'1+>i][[$i'1->i][[$i,*>i][[$i d"\n"d][">> "d]$c"o"=?]$c"s"=?]$c"d"=?]$c"i"=?['>i][]$i'256=$i'=|?\],._
=== Brainfuck interpreter ===
Brainfuck program is appended to the end of the interpreter. Output command is p, input is not supported. Loop is %bf[ code ]o.
 ["\n"d]#l_
 
 " type conversion commands "%
 [ ""@+ ]#s_
 [ "'"\\ ]#i_
 
 "Class tape"%
 
 	[@>self@>value@>name $value\ [$self:>a]\ $name s\] ~tape<set:2>
 	[@>self@>name [$self:$a]\ $name s\] ~tape<get:1>
 
 "Class bf"%
 
 	~bf<$i>
 	~bf<$tape>
 
 ^bf >bf
 ^tape , $bf:>tape >tape
 
 " tape initialization "%
 '1000 $bf:>i
 [,
 	'0 $bf:$i $tape:set
 	$bf:$i '1 -$bf:>i
 	$bf:$i!;
 \],._%
 
 '1 $bf:>i
 
 [$bf:$i $bf:$tape:get '1 @+ $bf:$i $bf:$tape:set]#+_
 [$bf:$i $bf:$tape:get '1 @- $bf:$i $bf:$tape:set]#-_
 [$bf:$i '1 @- $bf:>i ]#<_
 [$bf:$i '1 @+ $bf:>i ]#>_
 [@>bf @>loop [, $bf:$i $bf:$tape:get !; $loop._ \],._% ]#o2
 [$bf:$i $bf:$tape:get dl]#p_
 
 " bf hello world "% 
 ++++++++$bf[>++++$bf[>++>+++>+++>+<<<<-]o>+>+>->>+$bf[<]o<-]o>>p>---p+++++++pp+++p>>p<-p>+p>++p
== See also ==
* Fortob – The second language of the For series
Category:Languages Category:Object-oriented_paradigm Category:Stack-based Category:Self-modifying Category:Turing_complete