Owk
Owk is a compiled, esoteric, golfing, register-based programming language. created by User:Phase. that runs on the FVM. It is compiled into FVM bytecode, which can be put through the FVM for results.
Owk is parsed line by line. You can make a “fake” line by putting a ;. Comments start with # and are only at the start of a line, whitespace is ignored.
a=7 6=84 #The same as a = 7; 6 = 84
There are 16 registers in total, each marked by their hexadecimal counterpart. To load a number to these registers, we use =. (It basically overwrites whatever was in the register before.)
#Loads 8 to register f f=8 #You can also use capitals F=8
To load characters, you use ''. This will load the ASCII value of the character, though it can’t be over 255. Printing is done with p.
1='H';2='e';3='l';4='l';5='o';6=' ' 7='W';8='o';9='r';a='l';b='d' p1;p2;p3;p4;p5;p6;p7;p8;p9;pa;pb;
You can also do your normal math operations in Owk using the registers.
#Adds the values of registers a & f and stores it in register e e<a+f #Multiplies the values of registers 2 & d and stores it in register f f<2*d #Mods the values of registers 8 & 6 and stores it in register 1 1 < 8 % 6 #Transfers the value of register e into register f f<e
The available functions are add +, subtract -, multiply *, divide /, mod %, AND &, OR |, XOR ^, left shift <, and right shift >.
Expressions are done by wrapping it around (). It gets parsed by a JavaScript engine, so you can use things like Math.pow(). The answer of the expression can’t be over 255, so be careful!
f=(2*3+4) e=(Math.pow(2,3) + 7)
Since Owk is parsed line by line, you can use the g operator to go to a specific line.
#Infinite Loop f=8;e=6 f=f*e;g1 #The number after g is written in hex</source>
Negative numbers can be inputed like normal ones.
#Negative 2 f=-2 #NOT 2 e=!2 #Two's complement 2 d=~2
You can also negate registers.
#Negative c f<-c #NOT c e<!c #Two's complement c d<~c
Lambdas
Lambdas are a special part of Owk, and how functions are written. Then are notated in Lambda Calculus, which is different than your normal (x) -> x.
square:λx.x*x add:λx.λy.x+y
Each lambda begins with a name, followed by a : and the function code. Each λ notates a varaible use by the lambda, followed by a . and more variables or the function code. Here’s a side by side example of a Java method and an Owk lambda:
int add(int x, int y) {
return x + y;
}
add:λx.λy.x+y
And a more complicated one:
int math(int x, int y) {
return x * x + y * y;
}
math:λx.λy.x*x+y*y;
To use these lambdas, we need to assign the output to a register. It’s inputs will be in parentheses.
f=math(e,d)
External Resources
Separate implementation:
README.md
# Owk Owk is a compiled, esoteric, golfing, register-based programming language invented by Phase. This is an attempt of making Owk golfier. Owk is parsed line by line. You can make a "fake" line by putting a `;`. Comments start with `#` and are only at the start of a line, whitespace is ignored. ```python a=7 b=84 #The same as a = 7; b = 84 ``` There are 52 registers in total, each marked by a letter in the alphabet, whether capital or not. To load a number to these registers, we use `=`. (It basically overwrites whatever was in the register before.) ```python #Loads 8 to register f f=8 #This loads into a different register F=8 ``` To load characters, you use `'`. This will load the ASCII value of the character, though it can't be over **`255`**. Printing is done with `.`. ```python a='H;b='e c='l;d='l e='o;f=' g='W;h='o i='r;j='l k='d .a;.b .c;.d .e;.f .g;.h .i;.j .k ``` You can also do your normal math operations in Owk using the registers. ```python #Adds the values of registers a & f and stores it in register e e=a+f #Multiplies the number 2 & d and stores it in register f f=2*d #Mods the numeric values 8 & 6 and stores it in register a a=8%6 #Transfers the value of register e into register f f=e ``` The available functions are add `+`, subtract `-`, multiply `*`, divide `/`, mod `%`, AND `&`, OR `|`, XOR `^`, left shift `<`, and right shift `>`. Expressions are done by wrapping it around `()`. It gets parsed by a Python engine, so you can use things like `**`. The answer of the expression can be over **`255`**. When outputted though this gets modulo'd by 256. ```python f=2*3+4 e=2**3 + 7 ``` Negative numbers can be inputed like normal ones. ```python #Negative 2 f=-2 #NOT 2 e=!2 #Two's complement 2 d=~2 ``` You can also negate registers. ```python #Negative c f=-c #NOT c e=!c #Two's complement c d=~c ``` ## Lambdas Lambdas are a special part of Owk, and how functions are written. Then are notated in [Lambda Calculus](https://en.m.wikipedia.org/wiki/Lambda_calculus), which is different than your normal `(x) -> x`. ```python # There are 26 possible parameters stored in # registers a-z. square:a*a add:a+b ``` Each lambda begins with a name, followed by the function code. Here's a side by side example of a Python method and an Owk lambda: ```python add=lambda a,b:a+b ``` ```python add:a+b ``` And a more complicated one: ```python math=lambda x,y:x*x+y*y ``` ```python math:a*a+b*b ``` To use these lambdas, we need to assign the output to a register. Its inputs will be in parentheses. ```python f=math(e,d) ``` There is another separate way to write functions: ```python @A:A() ``` @ indicates that this is a function, and also this allows recursion to be done. ```A()``` is a function here. This is not lowercase because the parameters for a function will be in lowercase, and you can't call a function parameter. ## Conditionals Owk allows a simple form of conditional switching: ```python a=1-1&1|0 ``` This compares 1 and 1 and checks whether they are equal. If so, the value 1 is assigned to a. Otherwise the value 0 is assigned to a.
owk.py
import sys
file=open(sys.argv[1],'r')
text=file.read()
output=""
i=0
while i<len(text):
if text[i]==';':
output+='\n'
elif text[i]==' ':
pass
elif text[i]=='#':
while text[i]!='\n':
i+=1
elif text[i]=="'":
output+="ord('"
output+=text[i+1]
output+="')"
i+=1
elif text[i]=='.':
output+='print(chr('
output+=text[i+1]
output+='),end="")'
i+=1
elif text[i]=='<':
output+='<<'
elif text[i]=='>':
output+='>>'
elif text[i]=='!':
output+='int(not '
i+=1
try:
while text[i]!='\n'and text[i]!=';':
output+=text[i]
i+=1
except:
pass
output+=')'
i+=1
elif text[i]==':':
output+='=lambda '
j=i
try:
while text[j]!='\n'and text[j]!=';':
j+=1
except:
pass
a=""
for x in range(ord('a'),ord('z')+1):
if chr(x) in text[i:j]:
a+=chr(x)+','
a=a[0:-1]
output+=a+text[i:j]
i=j-1
elif text[i]=='@':
output+='def '
i+=1
while text[i]!=':':
output+=text[i]
i+=1
output+='('
j=i
try:
while text[j]!='\n' and text[j]!=';':
j+=1
except:
pass
a=""
for x in range(ord('a'),ord('z')+1):
if chr(x) in text[i+1:j]:
a+=chr(x)+','
a=a[0:-1]
print(a)
output+=a
output+='):return '
else:
output+=text[i]
i+=1
print(output)
exec(output)
print(A())