zlang 1.0.3

Lightweight and expressive programming language similar to Python

Zink

Zink is a programming language that simplifies scripting with many tweaks and additions.

Why Zink and not other languages?

One of the problems developers face when writing in other languages is that it can sometimes be very complex to write simple expressions, like for example iterating through a list while also getting the current item's position in that list in Python, which uses the enumerate function.

Zink simplifies these kinds of operations by letting the developer write shorter code and still converting it to the correct functions.

Quick comparison

This Python script determines if a number is prime:

def is_prime(n: int) -> bool:
    if n <= 1: return False
    if n <= 3: return True
    if n % 2 == 0 or n % 3 == 0: return False

    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

This here is that same code written in Zink:

def is_prime(n: int): bool
    if n <= 1; <-False;.
    if n <= 3; <-True;.
    if n % 2 == 0 or n % 3 == 0; <-False;.

    i = 5
    while i * i <= n
        if n % i == 0 or n % (i + 2) == 0
            <-False
        .
        i += 6
    .
    <-True
.

It may seem stupid (and longer), but now look at Python classes:

class Animal:
    def __init__(self, name: str) -> None:
        self.name = name
    def eat(self, food: str) -> None:
        print(self.name, "is eating", food)

class Bird(Animal):
    def __init__(self, name: str, color: str) -> None:
        super().__init__(name=name)
        self.color = color
    def fly(self) -> None:
        print(self.color, self.name, "is flying")

And look at those same classes in Zink:

class Animal
    def __init__(@, @name: str): None;;.

    def eat(@, food: str): None
        print(@.name, "is eating", food)
    .
.

class Bird from Animal
    def __init__(@, ^name: str, @color: str)@: None;;.

    def fly(@): None
        print(@.color, @.name, "is flying")
    .
.

You can start to notice that it simplifies many things that require a lot of time to type: it replaces entire lines spent typing self.foo = foo to simply putting a @ before the argument, or automatically passing those arguments to the super().__init__ function with ^. In fact, that very function is abbreviated to @^.

Getting the length of an object is as easy as typing # before the object, and converting an object to a type is done with the repurposed keyword as.

Here's a comparison between Zink and Python:

Python	Zink
type(a)	a as type
a.upper()	↑a
a.lower()	↓a
a()	a!
print(a)	:::a
self	@
self.a = a	@<-a
super()	^
super().__init__	@^
a = a.b	a .= b
for i, x in enumerate(a)	for x at i in a
range(10)	{->10}
range(2, 5)	{2<->5}
try: ... except: pass	try ...
try: ... except: ...	try ... catch ...
x <= a <= y	(a between x, y)

Language support

Zink is also built with the idea of writing the same code while still converting it to many languages, like for example writing the source code in Zink and then converting it to both Python and Ruby. The bin folder here contains the main file zink (that requires the language we're trying to convert to as the first parameter) and a bunch of "helper" files like zpy which is exactly the same as calling zink py.