AsciiDots

= AsciiDots = By Aaron Janse

AsciiDots is an esoteric programming language based on ascii art. In this language, dots, represented by periods, travel down ascii art paths and undergo operations.

Samples
Hello world:

.-$&quot;Hello, World!&quot;

Quine:

($'.-#40-$_a#-#35-$_a#-#39-$_a#) Counter:

/1#-.    |   /-+-$#\   | |   |  [+]&lt;1#-* |    |   \--&lt;--/ |     0      #      |      . Semi-compact factorial calculator:

/-*--~-$#-&amp; | /--;---\| [!]-\ | *--++--*#1/ | | /1#\ || [*]*{-}-*~&lt;+*?#-. *---+-&lt;/ \-#0/ Code-golfed counter (16 bytes):

/#$&lt;. \#1/
 * -[+]

Implementation
The original implementation is written in Python and is on Github It can be tried out online at asciidots.herokuapp.com

Starting a program
(a period), or  (a bullet symbol), signifies the starting location of a dot, the name for this language's information-carrying unit. Each dot is initialized with both an address and value of.

Ending a program
Interpretation of a dots program ends when a dot passes over an. It also ends when all dots die (i.e. they all pass over the end of a path into nothingness)

Comments
Everything after  (two back ticks) is a comment and is ignored by the interpreter

Paths
(vertical pipe symbol) is a vertical path that dots travel along  is a horizontal path that dots travel along

Note: Only one path should be adjacent to a starting dot location, so that there is no question where it should go

Here's an example program that just starts then ends (note that programs aren't always written and run top-to-bottom):

. `` This is where the program starts &amp; `` The program ends Think as these two paths as mirrors:
 * `` The dot travels downwards
 * `` Keep on going!

So... here's a more complex program demonstrating the use of paths (it still just starts then ends):

/-&amp;        `` This is where the program ends! \-\ /-\ | | | /-/ | \-\ \---/   |        |        \-. `` Here's where the program starts

Special Paths
is the crossing of paths (they do not interact)

acts like a regular, 2-way, horizontal, path, except dots can be inserted into the path from the bottom or the top. Those dots will go to the right  does likewise except new dots go to the left   (caret) does this but upwards   (the lowercase letter 'v') does likewise but downwards

Here's a way to bounce a dot backwards along its original path using these symbols:

/-&gt;-- `` Input/output comes through here \-/ But there is an easier way to do that:

reflects a dot backwards along its original path. It accepts dot coming from the left, and lets them pass through to the right  does likewise but for the opposite direction

duplicates a dot and distributes copies including the original dot to all attached paths except the origin of dot

Here's a fun example of using these special paths. Don't worry—we'll soon be able to do more than just start then end a program.

/-\ /-&amp; `` End | | | \-+-v | | /-\ (-&lt;-/ | | | |   \-&lt;-/  \-\    |    .    `` Start

Addresses and Values
sets the address to the value after it following the direction of the line  does the same except it sets the value

Interactive Console
is the output console. If there are single/double quotation marks ( or  ), it outputs the text after it until there are closing quotation marks. and  are substituted with the dot's value and address, respectively     When   follows a , the program does not end printing with a newline. When not in quotes, if a  comes before a   or   symbol, the value is converted to ascii before it is printed

Here's how to set and then print a dot's value:

. `` This dot is the data carrier | `` Travel along these vertical paths # `` Set the value... 3 ``   ... to 3 | `` Continue down the path $ `` Output to the console... # ``   ... the dot's value Here's our hello world again:

.-$&quot;Hello, World!&quot; Here's how to print that character 'h' without a newline:

.-$_&quot;h&quot; And this prints '%' using the ascii code 37:

.-#37-$a# is input from the console. It prompts the user for a value, and pauses until a value is entered in. It only runs after a  or   symbol

. `` Start | # `` Get ready to set the value ? `` Prompt the user | $  # `` Print that value to the console `` Since the only dot goes off the end of the path, it dies. Since no dots are left, the program ends

Control Flow
(tilde) redirects dots going through it horizontally to the upward path if a dot waiting at the bottom has a value not equal to than. Otherwise, the dot continues horizontally. If an exclamation point is under it, then it redirects the dot upwards only if the value of the dot waiting is equal to zero. acts like a pipe. Special function described above

This example prompts for a value then prints to the console whether the user provided value is equal to zero:

/-$&quot;The value is not equal to zero&quot; | .-~-$&quot;The value is equal to zero&quot; | ?  #  |.

Operations
multiplies the value that passes through vertically by the value that runs into it horizontally. When a dot arrive here, it waits for another dot to arrive from a perpendicular direction. When that dot arrives, the dot that arrived from the top or bottom has its value updated and it continues through the opposite side. The dot that passed through horizontally is deleted. does likewise except it multiplies the value that enters horizontally by the value that enters vertically. The resulting dot exits horizontally

Other operations work similarly but with a different symbol in the middle. This is the key to these symbols: : multiplication  : division  : also division  : addition  : subtraction  : modulus  : exponent  : boolean AND  : boolean NOT  : boolean OR  : boolean XOR  : greater than  : greater than or equal to  : less than  : less than or equal to  : equal to  : not equal to

Boolean operations return a dot with a value of  if the expression evaluates to true and   if false.

These characters are only considered operators when located within brackets. When outside of brackets, symbols like  perform their regular functions as described earlier.

Example:

`` Simple subtraction: ``  (3 - 2 = 1)

#  $   |  [-]-2#-.   |   3   #   |   . Add two user inputted values together then output the sum:

.-#?-{+}-$#     | .-#?--/

Warps
A warp is a character that teleports, or 'warps', a dot to the other occurrence of the same letter in the program.

Define warps at the beginning of the file by listing them after a. The  must be at the beginning of the line.

Example:

%$A

.-#9-A `` Create a dot, set its value to 9, then warp it

A-$#  `` Print the dot's value (9) Here's a fun example of using warps (although it is not very useful in this case)

%$A

$ | \&gt;-A \-3#-.

A-\ \-/

Libraries
Dots supports libraries! A library is a program that defines a character (usually a letter).

Using Libraries
A library can be imported by starting a line with, followed with the file name, followed with a single space and then the character that the library defines.

By default, all copies of the character to lead to the same (singleton) library code. This can cause some unexpected behavior if the library returns an old dot, since that old dot will come out of the char that it came from.

Here's an example of importing the standard  library (located in the   folder) as the character  :

%!for_in_range.dots f The way to use a library varies. Inputs and outputs of the library are through the alias character.

For the  library, the inputs are defined as follows: - The dot coming from the left side sets the starting value of the counter - The dot coming from the right sets the end value of the Counter

And the outputs are as follows: - A dot for each number within the range defined by the inputs is output from the top - When the loop is complete (the end value has been reached), a dot is output from the bottom

Here is an example of outputting all the numbers between  and   to the console, then stopping the program:

%!for_in_range.dots f

#        $         | .-*-#1---f-\ \-#100-+-/        |         &amp;

Creating Libraries
Each library defined a character that will act as a warp to &amp; from the library.

That can be done like so:

%$X `` X could be replaced with a different character, if so desired It is recommended that you create warps for different sides of the char. Just look at the example code for the  library:

Here's the code for a library that accepts a dot coming from the left, sets its value to its address, and then outputs it to the right:

%^X %$AB

B-X-A

A-*@{+}-#0-B |     |  \--/

Interpretation
Each tick, the dots will travel along the lines until they hit a character that acts as a function of multiple dots (i.e. an operation character or a  character). The dot will stop if it goes on a path that it has already traversed in the same tick

Due to the fact that dots may be moving backwards down a line, if a number or system value (e.g. ) is seen without a preceding   or , it will be ignored, along with any   or   immediately thereafter

More Examples
Hello, World!

.-$&quot;Hello, World!&quot; Counter:

/1#-.    |   /-+-$#\   | |   |  [+]&lt;1#-* |    |   \--&lt;--/ |     0      #      |.

Find prime numbers:

%$T

.       |        #        3        |        @        1        | /--*--*-&lt;--\ \-{+}-+-* 01 |      | |  ## |      | v--*+-/ | | ||    /-* |  *+--\    | T |  ||  | # $ # /~/ |    0 # 1 */   |    | | | |    |    \-&gt;-+-~&lt;-#$-2#-. \-/
 * # |   v+-0@-~-\
 * 2 | /-&gt;~*{%}/ |
 * | | 1  |\-+---/
 * | | 1  |\-+---/

/\ T       | *~ |       | \-*@[=]   |      |   \--#1--/

-

And a game!

/-&quot;&quot;$-. \--$&quot;Pick a number between 1 and 255 (inclusive)&quot;\ // \--$&quot;I will correctly guess that number after no more than 8 tries&quot;\ /---&quot;&quot;$/ \--$&quot;After each of my guesses, respond with: &quot;\ /-/ \--$&quot;    '2' if I guess too high,&quot;\ /--/ \--$&quot;    '1' if I guess too low,&quot;\ /-/ \--$&quot; or '0' if I guess correctly&quot;\ /--/ 6        |          /*-{-}*  | | | 4  /2#\   |     /~-+--+-+-+-#7-$a_#-$&quot;I won! Good game!&quot;-&amp; \&gt;~# #     \-?#-*-+/     | |1 1  /$&quot;&quot;-$#-/ |          | \/ |  ~-*--&lt;-821#-. \--/
 * /-&gt;-\
 * /--\ /-[-]| |
 * 1)         |           /#1\-~--+[+]|
 * 1)         |           /#1\-~--+[+]|
 * /{÷}-*---*    */     |/-~-/ |

External Resources

 * 1) Main Github repo
 * 2) It got a writeup on Motherboard!