InDec

InDec (Increment Decrement) is an esoteric programming language developed by Ettore Marmo in 2013.
==Overview==
There is no proper variable declaration in InDec, any alphanumeric string is a positive integer variable set to zero.
Values cannot be assigned directly, the only possible operations on a variable are increase by one (++) or decrease by one (--).
 a++
Instantiate the variable 'a' and add one to it.
The numbers used are strictly greater or equal to 0, trying to decrement a zero valued variable in an algorithm will not stop the execution of the program but it's not a recommended practice.
The curly brackets after an expression initiates a 'while' loop that gets executed only if the variable in the header is equal to zero
 a { do stuff... } 
Note that
 a ++ ++ ++ { ... }
actually modifies the variable 'a', InDec is meant to be very low-level, it translates 
The command 
 ()
breaks the loop.
The logical values are therefore inverted, 0 is True and everything else is False. 
Comments are enclosed between two double slashes
 // This is a comment //
Semicolons add line breaks so that statements can be written in the same line at the expense of readability
==Suffixes==
A strange kind of suffixed functions can be defined in InDec with the keyword @. They have the following characteristics
* They must have at least one parameter
* They always return the first parameter
 fn @ x,y,z {
 ...
 }
translates to
 function fn(x,y,z) {
 ...
 return x
 }
When a suffix is applied with one or more variables as arguments, it modifies the first
 a,b,c fn // a = fn(a,b,c) //
Function composition being lazily and badly implemented in the interpreter is a bit problematic and it does only work on one-argument functions.
 a,b,c fn other // a = other(fn(a,b,c)) // 
The basic operators can be applied as well with the following results
 a,b,c fn -- // a = fn(a,b,c)-1 //
But for some reasons it behaves oddly in some cases
 a,b,c fn -- other
 a = other(fn(a,b,c)) -1
==Output==
InDec has a lot of nice ways to output values, the most basic being
Assuming a=64, b=5, c=33
 a . // outputs 64 //
 a,b,c . // outputs 64533 //
An & after a variable makes it being displayed as its corresponding character
 a&,b,c . // outputs @533 //
 a&,b,c& . // outputs @5! //
An ? used in the same way prints True if the variable is equal to zero, False otherwise 
 a?,b . // outputs False5 //
A trailing comma after the '.' chops the newline after printing so that
 a&.,
 b.,
outputs @5 in the same line
For better readability (or at least in the author's opinion) when applied after a multi-argument suffix, only prints the first one
 a,b,c fn .
translates to
 a = fn(a,b,c) 
 print(a)
==Import==
Every file .indec file is also a module that can be imported with the following syntax
 module1,module2,module3 import
	
==The Interpreter==
Written in python3.3 translates and executes .indec files.
 python3 InDec.py filename.indec
The following arguments can be appended to the command
 -d	Debug (prints the translated python code)
 -t Prints the time elapsed during the compilation and execution of the program
It can be downloaded here https://github.com/hektor41/Esolangs/tree/master/InDec
It comes with some useful modules such as Operations, Logic etc...
==Examples==
This language is so low-level it doesn't have comparison operators or logic gates or even basic arithmetic functions, but
it's powerful enough for them to be implemented (it's also fun to do).
Basic adders that simulates number assignments
 add2 @ N { N add1 add1 }
 add4 @ N { N add2 add2 } 
 add8 @ N { N add4 add4 }
 a add4 ++ // a = 5 //
Set N to zero
 zero @ N {
 c // Declare variable c
 N {	 // If N is already zero, skip the following loop by incrementing c
 c++		 // And then break the outer loop by incrementing c
 () // break
 }			
 c { // If N was larger than zero
 N-- { // Decrement it until is equal
 c++ // And then break the outer loop by incrementing c
 () // break
 }
 }
 	 // omitted return N
 }
In the condensed form
 zero @ N {c;N{c++()}c{N--{c++()}}}
Note that there is no need for semicolons before the break () statement and after the closed brackets
A related function
 one @ N {N zero ++} //Set N to 1//
Every logical operator can be constructed using the two previous functions
 //AND gate//
 and @ R,P,Q {
 P {R one;Q{R zero()}()}
 Q {R one;P{R zero()}()}
 }
The convention with these operators is to use three arguments where the first 'R' is the result and the other two are the
values to compare so that P and Q won't get modified during the operation.
It can be useful when dealing with loops
 c,a,b and {
 	...	
 }	
means
 c = and(c,a,b)
 while c {...}
and a and b are left untouched
Addition
 add @ X,Y {
 	 // Set X to X+Y //
 	 c
 	 Y {c++;()} // Catch X+0 //
 	 c {
 X++
 Y-- {c++;()}
 	 }
 }	
Multiplication
 mul @ X,Y {
 // Set X to X*Y // 
 c
 multiplicator,X add 
 Y {X zero;c++;()} // Catch X*0 // 
 c {
 X,multiplicator add
 Y-- {c++;()}
 }
 }
Factorial
 fact @ X {
 // Set X to X! // 
 c
 result++
 X {c++;()} // 0! = 1 // 
 c{
 result,X mul
 X--{c++;()}
 }
 // X's value is now zero //
 X,result add // X's value is now the result //
 }
The whole language is completely inefficient (computing 10! takes 30.4335 seconds), but that's not much of a surprise is it? 
Everything is still being worked on if you have any idea write it in the talk section 
===HelloWorld.indec===
 Operations import
 
 SPACE add32
 H add64 add8
 d,H add add16 add8 add4
 e,d add ++
 l,e add add4 add2 ++
 o,l add add2 ++
 W,H add add8 add4 add2 ++
 r,o add add2 ++
 
 H&,e&,l&,l&,o&,SPACE&,W&,o&,r&,l&,d& .
 // Always leave some newlines at the end of the file just in case... //
Category:Languages
Category:Low-level
Category:2013
Category:Output only
Category:Implemented