Powerlist

Powerlist is an esoteric programming language created by User:CodingBat in April 2014. Designed to compute high level arithmetic operations (such as powers or logs) while keeping the syntax minimalistic.
It uses a single data structure type, but provides an extensive number of overridable operators.
=Header=
Any Powerlist program must have a header which defines the structure of the only variable type allowed. Each header line is a characteristic of the variable, and is enclosed in dollar ($) symbols.
==Bit structure line==
The first line of the header defines the use of each bit of the type, if the total of bits defined is not a multiple of 8, the computer will assign the minimum byte number needed, making no use of the undefined bits.
===Bit usage syntax===
The line is made but contatenating the following characters:
Character	Meaning 	Explanation
S 	Signum bit 	A type which lacks this bit will be unsigned, if more than one is present, they will all have the same value.
e 	exponent bit 	Define a bit in the exponent part of a floating-point type. The type will be fixed-point if none is present.
E 	exponent half-byte	Syntaxic sugar for eeee
d 	decimal bit 	Define a bit in the decimal part of a fixed-point type. The type will be integer if none is present.
D 	decimal half-byte 	Syntaxic sugar for dddd
m 	mantissa bit 	If floating-point type, will define the mantissa part. If fixed-point type, will define the integer part.
M 	mantissa half-byte	Syntaxic sugar for mmmm
===Character encoding syntax===
The last character of the line defines the character encoding format the program will use. It is also the format the source file will be interpreted as using.
Character	Character encoding
A 	7-bit ASCII
E 	8-bit extended ASCII
3 	UTF-8
4 	UTF-16
5 	UTF-32
J 	JIS
Example: Possible implementation of an ASCII type
 $SmmmMA$
Example: Possible implementation of classical single-precision floating-point type
 $SEEMmMmMmMM3$
==Special behaviours lines==
The other lines of the header override the default behaviour of a give type. This allows things like NaN, INF, -INF values.
===Value selection syntax===
Each line needs one or more values to be selected, here's the syntax to select a value:
Character(s)	Meaning
0 	Bit of value zero
1 	Bit of value one
? 	Bit of either value
: 	Equivalant to the preceding character, repeated for the rest of the bits
*x* 	Equivalent to the preceding character, repeated x times (x being a integer litteral in base 10)
- 	Whatever value the bit used to have before an arithmetic operation (only for the third value selection in operatop, definition lines (see below))
Example: Value with all bit at 1
 1:
Example: Value with the first bit being either 1 or 0, the ten next bits at 1 then all others at 0
 ?1*10*0:
===String redefinition syntax===
String redefinition lines will affect a special displaying behaviour for the given value that isn't the default. They are written by typing a value then an operator, then a string of characters between quotation marks. The operators are:
Operator	Effect
P 	Rededines the way the "Print" operation will print the value on the screen (see Print for more information)
D 	Rededines the way the "Display" operation will print the value on the screen (see Display for more information)
S 	Rededines the way the "Scan" operation will parse the value inputted (see Scan for more information)
T 	Rededines the way the "Type" operation will parse the value inputted (see Type for more information)
s 	Rededines the way the "ScanNumber" operation will parse the value inputted (see ScanNumber for more information)
Example: A value with all bits at 1 but the first will be printed as "+INF", and a value with all bits at 1 will be printe as "-INF"
 $01:P"+INF"$
 $1:P"-INF"$
===Operation redefinition syntax===
Operation definition lines will change the effect a given value will result once affected to an arithmetic operation. They take three value selections, the two first separated by the arithmetic operator, the second and the third separated by the equality symbol (=). Operators availables for redefinition are:
Operator	Name
* 	Power (a*n = nth power of a)
/ 	Root (a/n = nth root of a)
\ 	Logarithm (a\n = logarithm base n of a)
Example: Sets "zero to the power of zero" to return zero (default behaviour returns 1)
 $0:*0:=0:$
Example: Sets the logarithm of a negative number to return -0 (assuming the variable type's first bit being a signum, and not being floating-point)
 $1?:\?:=10:$
=Comments=
Any text between parenthesis (()) is interpreted as comments and thus ignored.
=Lists=
The defined variable type is only used internally by the Powerlist program. The programmer must use another data structure: the list.
A list contains values, but unlike a C array, you can't access an arbitrary element of it. You can only access the first and the last item.
Lists are the only kind of data structure provided by Powerlist.
Lists names can be any characters allowed by the defined character encoding (including digits), with the exeption of $, ~, >, <, ?, :, +, !, {, }, _, @, ^, [, ], =, ;, ( and )
It is also not allowed to name a list "..." (three full stops).
===Operators===
Here are the operators available to manipulate lists (applied on a example list named List):
Operation syntax	Name 	Overridable?	Description 	Notes
~ List ~ 	Creation 	No 	Instanciates an empty list named List 	Using a non-created list or applying the Creation operator on an already created list causes the program to end
> List 	Head Push 	Yes 	Inserts a value in front of the list 	
List < 	Tail Push 	Yes 	Inserts a value in end of the list 	
List ? 	Length 	Yes 	Returns the length of the list 	
: List 	Head Clone 	Yes 	Head-pushes a copy of the first value of the list 	No effect if the list is empty
List : 	Tail Clone 	Yes 	Tail-pushes a copy of the last value of the list 	No effect if the list is empty
< List 	Head Pop 	Yes 	Removes and returns the first value of the list 	Returns an empty list if the list is empty
List > 	Tail Pop 	Yes 	Removes and returns the last value of the list 	Returns an empty list if the list is empty
<+ List 	Global Head Pop 	Yes 	Head-pops all values of the list 	Default implementation makes use of the Head Pop and the Length operators
List +> 	Global Tail Pop 	Yes 	Tail-pops all values of the list 	Default implementation makes use of the Tail Pop and the Length operators
< Rep ! List 	Repeated Head Pop	Yes 	Head-pops Rep times 	Default implementation makes use of the Head Pop operator
List ! Rep > 	Repeated Tail Pop	Yes 	Tail-pops Rep times 	Default implementation makes use of the Tail Pop operator
List { code } 	Length Loop 	Yes 	Executes the Powerlist code between brackets until the list's length is 0 	Default implementation makes use of the Length operator
_ List _ 	Deletion 	No 	Free the variable name 	Variable names take up memory until freed
~ Child @ List ~	Metacopy 	No 	Instanciates an new list (named Child in this example) with the same operator overrides as the parent list 	Does not copy the values stored in the parent list
List ^ 	Default Form 	No 	List with all operators at default implementation (before any override). Useful for override 	
List @ 	Parent Form 	No 	List with all operators at parent implementation (just after the Metacopy). Useful for override, comparable to super in Java.	For lists instanciated with the Creation operator, same effect as List^
Pop operators that feed into another list will automaticly push in it from the fitting side.
===Anonymous lists===
For faster creation of lists, Powerlist provides a syntax to create anonymous lists. Anonymous lists are deleted once the program stops using it.
An anonymous list is created by enclosing it's content between square brackets ([]), and separating each element with a semicolon (;).
Example: This code creates a list named List and adds to it the values 1, 2, 3, 4, in that order.
 ~List~
 List <+ [1 ; 2 ; 3 ; 4]
For anonymous lists the Head Pop and Tail Pop operators behave like the Global Head Pop and the Global Tail Pop respectively, as a syntaxic sugar. So List<[1, 2] does the same as List<+[1, 2]
====String lists====
A special kind of anonymous list allows to create string literals. String lists a created by enclosing the desired string of characters in quotation marks ("")
Example: This code creates a list named List and adds to it the numeric values for each character of the string "List".
 ~List~
 List < "List"
This code has the same effect as
 ~List~
 List < [ 76 ; 105 ; 115 ; 116 ]
===Literal lists===
Powerlist provides built-in lists which provide a single value.
These lists have valid names according to the list naming specifications of the language, so they can be freely Created, Deleted, Metacopied and have their operators overriden, though it is frown upon to do so as they provide basic values needed by most programs.
The Push and Clone operations has no effect on them, their Length is 0, the Pop and Global Pop operations both return a single instance of their value (though the Repeated Pop operations do provide the requested number of instances), and they are automaticly deleted when the program ends (no need to apply Delete on them).
As a syntaxic sugar, the literal list name without any operator is interpreted as a Pop operation in anonymous lists declaration (see above).
Any number literal is interpreted by the program as a litteral list that returns that number. Litteral list are just the number in base 10, with the comma (,) and full stop (.) both valid as decimal mark.
Example: This code push 42 in a list named List.
 List < 42
Other literal lists are *, /, \, ', &, |, ` and # (See arithmetic operations for more information)
==Operators override==
Most Powerlist list operators are overridable to alter the functionnalities of a given list. There is no "class" in Powerlist, each list overrides its operators independantly.
To override an operator, the syntax is to type the operator call, followed by the equal symbol (=), then the new code for the operator, then close with another equal symbol.
Inside the override's scope, a few named lists are provided to access some value otherwise unreachable.
Name	Operators 	Description
Self	All 	The calling list, anything done to this list is also done to the list the operator is called on
In 	Push and Repeated Pop operators	For Push operators: The input list, all the values the operator is trying to input are in this list
For Repeated Pop operators: A list with only one value: the number of times to repeat
Out 	Pop and Length operators 	The output list, everything the operator will output have be be in it. For the Length operator, only the first element will be actually outputted.
Example: This code overrides the Tail Push operator to push the given value twice.
 List< = 
 Self<:In
 Self<In
 =
The Length Loop operator override requieres a special syntax:
 List{} =
 (Code executed before the length check and first loop)
 {...
 (Code executed on loop start, before the code in the brackets at operator call is executed)
 ...
 (Code executed on loop start, after the code in the brackets at operator call is executed and just before the next length check)
 ...}
 (Code executed after the last loop, when the list's length is 0)
 =
=Arithmetic operations=
Arithmetic operations in Powerlist are not part of the syntax, instead a built-in list named "Computer" is provided for that purpose. Like other built-in functions, it can be overriden by any way, but this is frown upon because their behaviour is internal and no way is provided to copy their original behaviour.
The Computer list only compute one binary arithmetic operation at a time. When prompted with the Pop operator, the Computer list will take the 3 first values (or the 3 last, depending on which side the Pop operator is on) it holds and process the first and the third through on operation specified by the second. The value for each operation available is not set in the specification, and may change depending on implementation. Powerlist provides literal lists for the operations (*, /, \, ', &, |, ` and #).
The # is the only unary operation, the Computer list only processed 2 elements instead of 3 for the others.
The operations available are:
Literal list	Operation 	Description
* 	Power 	<Computer<[ a ; * ; n ] Returns a raised to its nth power
/ 	Root 	<Computer<[ a ; / ; n ] Returns the nth root of a
\ 	Logarithm 	<Computer<[ a ; \ ; b ] Returns the logarithm base a of b
' 	Equality 	<Computer<[ a ; ' ; b ] Returns ' if a equals b, 0 if not
& 	Bitwise And	<Computer<[ a ; & ; b ] Returns a AND b
| 	Bitwise Or 	<Computer<[ a ; | ; b ] Returns a OR b
` 	Bitwise Xor	<Computer<[ a ; ` ; b ] Returns a XOR b
# 	Signum 	<Computer<[ a ; ` ] Return the signum of a (1 if negative, 0 if positive)
As you can see, Powerlist doesn't implement First level (addition, subtraction) and Second level (multiplication, division) arithmetic operations. Those have been internalized to reduce the language's complexity. Plus, high-level programmers using this language obviously don't need such mundane operations anyway, and even in the rare event of any of those operations being needed, it is well known that the superior operations are able to implement inferior ones.
The rest of this chapter will be dedicated to prove that claim.
===Addition implementation===
 $SeeeEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMM$
 ~Add~
 <Add =
 Out<Computer<[2 ; * ; <Self^]
 Out<Computer<[2 ; * ; <Out]
 Out<Computer<[2 ; * ; <Self^]
 Out<Computer<[<Out ; * ; <Out]
 Out<+Computer<[2 ; \ ; <:Out ; 2 ; \ ; <Out]
 =
 Add> =
 [Self^> ; * ; 2]>Computer>Out
 [Out> ; * ; 2]>Computer>Out
 [Self^> ; * ; 2]>Computer>Out
 [Out> ; * ; Out>]>Computer>Out
 [Out:> ; \ ; 2 ; Out> ; \ ; 2]>Computer+>Out
 =
 Display<Add<[3 ; 2] (Print "5" on the screen)
===Subtraction implementation===
 $SeeeEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMM$
 ~Sub~
 <Sub =
 Out<Computer<[2 ; * ; <Self^]
 Out<Computer<[2 ; * ; <Out]
 Out<Computer<[2 ; * ; <Self^]
 Out<Computer<[Out> ; * ; -1]
 Out<Computer<[2 ; \ ; Out>]
 Out<Computer<[2 ; * ; Out>]
 Out<Computer<[<Out ; * ; <Out]
 Out<+Computer<[2 ; \ ; <:Out ; 2 ; \ ; <Out]
 =
 Sub> =
 [Self^> ; * ; 2]>Computer>Out
 [Out> ; * ; 2]>Computer>Out
 [Self^> ; * ; 2]>Computer>Out
 [-1 ; * ; <Out]>Computer>Out
 [<Out ; \ ; 2]>Computer>Out 
 [<Out ; * ; 2]>Computer>Out
 [Out> ; * ; Out>]>Computer>Out
 [Out:> ; \ ; 2 ; Out> ; \ ; 2]>Computer+>Out
 =
 Display<Sub<[3 ; 2] (Print "1" on the screen)
===Multiplication implementation===
 $SeeeEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMM$
 ~Mul~
 <Mul =
 Out<Computer<[2 ; * ; <Self^]
 Out<Computer<[<Out ; * ; <Self^]
 Out<Computer<[2 ; \ ; <Out]
 =
 Mul> =
 [Self^> ; * ; 2]>Computer>Out
 [Self^> ; * ; Out>]>Computer>Out
 [Out> ; \ ; 2]>Computer>Out
 =
 Display<Mul<[3 ; 2] (Print "6" on the screen)
===Division implementation===
 $SeeeEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMM$
 ~Div~
 <Div =
 Out<Computer<[2 ; * ; <Self^]
 Out<Computer<[<Self^ ; * ; -1]
 Out<Computer<[<Out ; * ; <Out]
 Out<Computer<[2 ; \ ; <Out]
 =
 Div> =
 [Self^> ; * ; 2]>Computer>Out
 [-1 ; * ; Self^>]>Computer>Out
 [Out> ; * ; Out>]>Computer>Out
 [Out> ; \ ; 2]>Computer>Out
 =
 Display<Mul<[3 ; 2] (Print "1.5" on the screen)
=Other built-in lists=
Name 	Description 	Notes
Bin 	Safely delete any value pushed in it 	Clone operators do nothing, Pop operators return an empty list, Length is always 0
Error 	Print any string pushed in it to the standard error output 	Clone operators do nothing, Pop operators return an empty list, Length is always 0
Print 	Print any string pushed in it to the screen 	Clone operators do nothing, Pop operators return an empty list, Length is always 0
Display 	Print any value pushed in it as a number base 10 on the screen 	Clone operators do nothing, Pop operators return an empty list, Length is always 0
Scan 	Retrieve a single character from the standard input when popped, more recent character being at the front of the list 	Push operators do nothing
Type 	When popped etrieve all character from the standard input until a line break is encountered, more recent character being at the front of the list If end is reached an no line break is found, wait until it gets one	Push operators do nothing
ScanNumber	Retrieve a number base 10 from the standard input when popped, more recent character being at the front of the list. If the input stream doesn't start with a number, returns an empty list 	Push operators do nothing
Format 	Pops a character list fitting the pushed in value 	Clone operators affect the pushed in value
Number 	Pops a value fitting the pushed in character string 	Clone operators affect the pushed in value
Kill 	Any operator force-closes the program 	
ENV 	Contains a list of environment values 	Clone and Push operators do nothing, Pop operators clones values before return them
=Turing-compleness proof=
The following program emulates the Brainfuck program +[-<,.>]:
 $MMA$
 ~Memory~
 Memory<<1024!0 (creates a 1024-cell memory tape)
 (start of program)
 
 (+)
 [<Memory ; * ; 2]>Computer>Memory
 [<Memory ; * ; 4]>Computer>Memory
 [<Memory ; \ ; 2]>Computer>Memory
 [<Memory ; \ ; 2]>Computer>Memory
 
 ([)
 ~Loop1~
 (Create an empty list, each brainfuck bracket pair needs its own list)
 Bin< <:Loop1 !Loop1<Computer<[<:Memory ; ' ; 0]
 (If the memory cell is 0, the loop will have 1 element, if not, the loop will be empty)
 Loop1{
 (If the list is not empty, enters the brackets, if not, skip the brackets) 
 
 (-)
 [<Memory ; * ; 2]>Computer>Memory
 [2 ; / ; 2]>Computer>Memory
 [<Memory ; * ; <Memory]>Computer>Memory
 [<Memory ; \ ; 2]>Computer>Memory
 [<Memory ; \ ; 2]>Computer>Memory
 
 (<)
 Memory>Memory
 
 (,)
 Bin<Memory
 Scan>Memory
 
 (.)
 Print<:Memory
 
 (>)
 Memory<Memory
 
 (])
 Bin<+Loop1
 (Empty the list)
 Bin< <:Loop1 !Loop1<Computer<[<:Memory ; ' ; 0]
 (If the memory cell is 0, the loop will have 1 element, if not, the loop will be empty)
 } _Loop1_
 (If the list is not empty, restart at the fitting bracket, if not, free the Loop1 list and go on)
 
 (end of program)
 _Memory_ (free the memory list)
=Example programs=
===Hello world!===
 $MMA$
 Print<"Hello world!"
===cat===
 $MMA$
 Scan { Print<[Scan>] }
===Truth machine===
 $MMA$
 ~Out~
 Bin < <:Out ! Out < Computer < [0 ; ' ; Scan>]
 Out { Display<1 }
 Display<0
 _Out_
Category:Unimplemented
Category:High-level
Category:Object-oriented_paradigm
Category:Functional_paradigm
Category:2014
Category:Turing_complete
Category:Deque-based
Category:Languages