From 1e11bad07989b28e310f3304bc71a37fefb662f4 Mon Sep 17 00:00:00 2001
From: Xanderplayz16 <gh.cli.is@broken.com>
Date: Sun, 15 Sep 2024 15:14:27 -0400
Subject: [PATCH] Initial commit

---
 ithon.py | 155 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 155 insertions(+)
 create mode 100644 ithon.py

diff --git a/ithon.py b/ithon.py
new file mode 100644
index 0000000..1be47aa
--- /dev/null
+++ b/ithon.py
@@ -0,0 +1,155 @@
+import tokenize, io
+
+PREFIX = """
+# ITHON START
+import sys as _INTERNAL_SYS
+class _INTERNAL_LazyIterable:
+    __slots__ = ('x','y')
+    def __init__(self, x, y) -> None:
+        self.x = iter(x)
+        self.y = iter(y)
+    def __iter__(self):
+        return _INTERNAL_LazyIterator(self)
+class _INTERNAL_LazyIterator:
+    __slots__ = ('iterable',)
+    def __init__(self, iterable) -> None:
+        self.iterable = iterable
+    def __next__(self):
+        try:
+            return next(self.iterable.x)
+        except StopIteration:
+            try:
+                return next(self.iterable.y)
+            except StopIteration:
+                raise StopIteration
+class _INTERNAL_LAZYMERGE:
+    def __init__(self, val):
+        self.val = val
+    def __rrshift__(self, other):
+        return _INTERNAL_LAZYMERGE(other)
+    def __lshift__(self, other):
+        return _INTERNAL_LazyIterable(self.val, other)
+class _INTERNAL_LPIPE:
+    def __init__(self, val):
+        self.val = val
+    def __rrshift__(self, other):
+        return _INTERNAL_LPIPE(other)
+    def __lshift__(self, other):
+        if isinstance(other, list):
+            other.append(self.val)
+        else:
+            return other(self.val)
+class _INTERNAL_RPIPE:
+    def __init__(self, action):
+        self.action = action
+    def __rrshift__(self, other):
+        return _INTERNAL_RPIPE(other)
+    def __lshift__(self, other):
+        if isinstance(self.action, list):
+            self.action.append(other)
+        else:
+            return self.action(other)
+
+_INTERNAL_lpipe = _INTERNAL_LPIPE(None)
+_INTERNAL_rpipe = _INTERNAL_RPIPE(None)
+
+_INTERNAL_lazymerge = _INTERNAL_LAZYMERGE(None)
+
+# ITHON END
+"""
+
+
+class lazy_typegetter:
+    class lazy_typegetter_iter:
+        def __init__(self, typegetter) -> None:
+            self.typegetter = typegetter
+            self.index = 0
+        def __next__(self):
+            try:
+                val: tuple[int, str] = self.typegetter[self.index]
+            except IndexError:
+                raise StopIteration
+            self.index+=1
+            return val
+    def __init__(self, tokens: list) -> None:
+        self.tokens = tokens
+    def __getitem__(self, item: int):
+        type, name, _, _, _ = self.tokens[item]
+        return type, name
+
+    def __iter__(self):
+        return self.lazy_typegetter_iter(self)
+
+
+def translate(file: io.StringIO):
+    patched_file = io.StringIO(PREFIX + file.read())
+    skip_token = 0
+    tokens = lazy_typegetter(list(tokenize.generate_tokens(patched_file.readline))) # Precalculate tokens
+
+    for n, i in enumerate(tokens):
+        type, name = i
+        try:
+            next_type, next_name = tokens[n + 1]
+        except IndexError:
+            next_type, next_name = (None, None)
+        print(type, name)
+        if skip_token:
+            skip_token -= 1
+            continue
+        if type == tokenize.OP and next_type == tokenize.OP:
+            # Most likely special operation
+            if name == "|" and next_name == ">": # left pipe
+                yield tokenize.OP, ">>"
+                yield tokenize.NAME, "_INTERNAL_lpipe"
+                yield tokenize.OP, "<<"
+                skip_token+=1
+            elif name == "<" and next_name == "|": # right pipe
+                yield tokenize.OP, ">>"
+                yield tokenize.NAME, "_INTERNAL_rpipe"
+                yield tokenize.OP, "<<"
+                skip_token+=1
+            elif name == ":" and next_name == ":": # lazy merge
+                yield tokenize.OP, ">>"
+                yield tokenize.NAME, "_INTERNAL_lazymerge"
+                yield tokenize.OP, "<<"
+                skip_token+=1
+            elif name == "+" and next_name == "+": # increment
+                yield tokenize.OP, "+="
+                yield tokenize.NUMBER, "1"
+                skip_token+=1
+            elif name == "-" and next_name == "-": # decrement
+                yield tokenize.OP, "-="
+                yield tokenize.NUMBER, "1"
+                skip_token+=1
+            elif name == "-" and next_name == ">": #
+                skip_token+=1
+            elif name == ")" and next_name == "=": # short functions
+                yield type, name
+                yield tokenize.OP, ":"
+                yield tokenize.NAME, "return"
+
+                skip_token += 1
+            else:
+                yield type,name
+
+        elif type == tokenize.OP:
+
+            if name == "<>": # barry is flufl
+                yield tokenize.OP, "!="
+            else:
+                yield type, name
+        else:
+            yield type,name
+
+script = """
+
+def fibonacci(x):
+    start = [0,1]
+    for i in range(1, x):
+        start <| start[i] + start[i - 1]
+    return start
+65536*16 |> fibonacci |> len |> print
+"""
+code = tokenize.untokenize(translate(io.StringIO(script)))
+print(code)
+exec(code)