comun.md

   1 # Comun
   2
   3 { UPDATE: I am currently thinking about reworking comun a bit, maybe drop the whole bytecode and build it more with the incremental style of Forth. I will probably need a lot more time to think it through, please be patient :-) ~drummyfish }
   4
   5 Comun is a [beautiful](beauty.md), experimental [minimalist](minimalism.md) [programming language](programming_language.md) made by [drummyfish](drummyfish.md) in 2022, based on his ideals of good, [selfless](selflessness.md) [technology](technology.md) known as *[less retarded software](lrs.md)* (LRS) -- it is still a very much work in progress and may potentially change a lot. It was planned that in the [future](future.md) it should gradually replace [C](c.md) as the preferred LRS language, however it's very soon for this still. The language has been inspired mainly by [Forth](forth.md) but also [C](c.md), [brainfuck](brainfuck.md) and other ones. Though already usable, it is still in development; currently there is a [suckless](suckless.md) implementation of comun in [C](c.md) as well as a basic [self hosted](self_hosting.md) one which can [bootstrap](bootstrap.md) itself and should gradually replace the C version. There is also a number of supplemental materials such as a specification, tutorial and some example programs. The project repository is currently at https://codeberg.org/drummyfish/comun. The aim now is to make a [self hosted](self_hosting.md) implementation, i.e. write comun in comun.
   6
   7 **How minimal is comun?** The specification fits on one sheet of A4 paper (using both sides) and the minimal self hosted compiler without preprocessor and fancy features has some 2400 [lines of code](loc.md), a lot of which are documenting comments (the whole self hosted codebase that also includes a more "feature rich" compiler, optimizer, interpreter etc. still has fewer than 5000 lines).
   8
   9 { NOTE: I found a language on esolang wiki called *Minim* that looks a bit similar to comun, however it looks a bit sucky. Anyway it should be researched more. ~drummyfish }
  10
  11 The language is intended to be the foundation of a completely new, non-[capitalist](capitalism.md) computer technology built from the ground up, which should culminate in the creation of the LRS much desired [public domain computer](public_domain_computer.md). This technology is derived from the model of an [ideal society](less_retarded_society.md) and as such will aim for completely different goals (such as helping all living beings as much as possible without enslaving them) and values; this makes comun astronomically different in philosophy and design of the shitty, toxic capitalist joke languages such as [C++](cpp.md) and [Rust](rust.md) which pursue fascism, enslavement of humans to the [productivity cult](productivity_cult.md) etc.
  12
  13 Comun is planned to closely interact with [comun shell](comun_shell.md), though the two parts will be completely independent.
  14
  15 **A quick sum up** is following: comun is **[minimalist](minimalism.md)**, **[low level](low_level.md)** with minimum [abstraction](abstraction.md), **[portable](portability.md)**, **[imperative](imperative.md)** and **[stack](stack.md)-based**, using **reverse Polish notation**. It can be **both [compiled](compiler.md) and [interpreted](interpreter.md)**. There are **only primitive integer [data types](data_type.md)** (native integer size by default with possibility to specify exact width where necessary, signed/unsigned interpretation is left to the programmer) and **optional [pointers](pointer.md)** that can be used as variables, for managing multiple stacks, creating [arrays](array.md) etc. Its **specification can fit on a sheet of paper** and is **completely [public domain](public_domain.md)** under [CC0](cc0.md) (as is its current implementation). It has **no [standard library](stdlib.md)**. There are **no [English](english.md) keywords**; commands are rather very short (mostly 1 to three symbols) math-like symbols. Source code only allows [ASCII](ascii.md) symbols (no [unicode](unicode.md)). There is an **optional [preprocessor](preprocessor.md) that uses comun itself** (i.e. it doesn't use any extra language). **[Functions](function.md) and [recursion](recursion.md)** are supported. Many features of the language are optional and never burden the programmer if he doesn't use them. Simplified versions of the language (minicomun and microcomun) are also specified. The only I/O in pure comun is standard input and standard output, i.e. there is no input/output from/to files, screen, network etc., the language merely processes input values into output values -- handling more complex I/O is left for libraries and/or comun's wrapping environment, such as [comun shell](comun_shell.md).
  16
  17 TODO: compare to Forth
  18
  19 ## Examples
  20
  21 Here is a very short showcase of comun code, demonstrating some common functions:
  22
  23 ```
  24 max: <' ? >< . ^ .      # takes maximum of two values
  25
  26 max3: max max .         # takes maximum of three values
  27
  28 # recursive factorial
  29 factR:
  30   ?'
  31     $0 -- factR *
  32   ;
  33     ^ 1
  34   .
  35 .
  36
  37 # iterative factorial
  38 factI:
  39   $0 --
  40
  41   @'
  42     >< $1 * ><
  43     --
  44   .
  45   ^
  46 .
  47 ```
  48
  49 The following is a [quine](quine.md) in comun:
  50
  51 ```
  52 0 46 32 34 S 34 32 58 83 S --> S: "0 46 32 34 S 34 32 58 83 S --> " .
  53 ```
  54
  55 The following code translates [brainfuck](brainfuck.md) to comun (proving comun really is [Turing complete](turing_complete.md)):
  56
  57 ```
  58 0 "$>0 " -->
  59
  60 @@
  61   <? ?
  62     <-
  63
  64     $0 "+" = $1 "-" = | ?
  65       $0 -> $0 -> " " ->
  66     .
  67
  68     $0 "<" = $1 ">" = | ?
  69       "$" -> $0 -> "0" -> " " ->
  70     .
  71
  72     $0 "." = ?
  73       0 "->' " -->
  74     .
  75
  76     $0 "," = ?
  77       0 "$<0 <- " -->
  78     .
  79
  80     $0 91 = ? # left bracket
  81       0 "@' " -->
  82     .
  83
  84     $0 93 = ? # right bracker
  85       0 ". " -->
  86     .
  87
  88     ^
  89   ;
  90     !@
  91   .
  92 .
  93 ```
  94
  95 The following is our standardized **[divisor tree](divisor_tree.md)** program written in comun:
  96
  97 ```
  98 # pops a number (< 1000) and prints it
  99 numPrint999:
 100   $0 99 > ? $0 100 / "0" + -> .
 101   $0 9 > ?  $0 10 / 10 % "0" + -> .
 102   10 % "0" + ->
 103 .
 104
 105 # converts single digit to number (or -1 if invalid)
 106 digitToNum:
 107   $0
 108
 109   $0 "0" >= >< "9" <= & ?
 110     "0" -
 111   ;
 112     ^ -1
 113   .
 114 .
 115
 116 # takes x, pops it and recursively prints its divisor tree
 117 printDivisorTree:
 118   -1 -1                 # divisors: a, b
 119
 120   $2 2 / @@             # for i = x / 2
 121                         # stack now: x a b i
 122     $0 1 <= ?
 123       !@
 124     .
 125
 126     $3 $1 % 0 = ?       # i divides x?
 127       $0 $:3            # a = i
 128       $3 $1 / $:2       # b = x / i
 129
 130       $2 $2 <= ?        # a <= b?
 131         !@
 132       .
 133     .
 134
 135     --                  # decrement i
 136   .
 137   ^                     # pop i
 138
 139   "(" ->
 140
 141   $0 -1 != ?
 142     printDivisorTree
 143     " " ->
 144     >< numPrint999      # print x
 145     " " ->
 146     printDivisorTree
 147   ;
 148     ^ ^                 # pop a, b
 149     numPrint999
 150   .
 151
 152   ")" ->
 153 .
 154
 155 @@                      # read numbers from the user
 156   0 10 "enter a number:" -->
 157
 158   0                     # x
 159   @@                    # read x
 160     <-
 161     $0 10 = ? ^ !@ .    # newline?
 162     digitToNum
 163     $0 -1 = ? !. .      # wrong digit? then end
 164     >< 10 * +
 165   .
 166
 167   $0 1000 < ?           # x < 1000?
 168     printDivisorTree
 169     10 ->               # newline
 170   ;
 171     !@
 172   .
 173 .
 174 ```
 175
 176 ## See Also
 177
 178 - [comun shell](comun_shell.md)
 179 - [MIX](mix.md)
 180 - [uxn](uxn.md)
 181 - [minim](minim.md)
 182 - [Oberon](oberon.md)
 183 - [C](c.md)