Change the structure of the .erg directory

compiler/erg_compiler/lib/std/_erg_std_prelude.py

@@ -0,0 +1,107 @@
+from collections.abc import Iterable, Sequence, Iterator, Container
+
+def in_operator(x, y):
+    if type(y) == type:
+        if isinstance(x, y):
+            return True
+        # TODO: trait check
+        return False
+    elif (type(y) == list or type(y) == set) and type(y[0]) == type:
+        # FIXME:
+        type_check = in_operator(x[0], y[0])
+        len_check = len(x) == len(y)
+        return type_check and len_check
+    elif type(y) == dict and type(y[0]) == type:
+        NotImplemented
+    else:
+        return x in y
+
+class Range:
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+    def __contains__(self, item):
+        pass
+    def __getitem__(self, item):
+        pass
+    def __len__(self):
+        pass
+    def __iter__(self):
+        return RangeIterator(rng=self)
+
+Sequence.register(Range)
+Container.register(Range)
+Iterable.register(Range)
+
+# represents `start<..end`
+class LeftOpenRange(Range):
+    def __contains__(self, item):
+        return self.start < item <= self.end
+    def __getitem__(self, item):
+        return NotImplemented
+    def __len__(self):
+        return NotImplemented
+
+# represents `start..<end`
+class RightOpenRange(Range):
+    def __contains__(self, item):
+        return self.start <= item < self.end
+    def __getitem__(self, item):
+        return NotImplemented
+    def __len__(self):
+        return NotImplemented
+
+# represents `start<..<end`
+class OpenRange(Range):
+    def __contains__(self, item):
+        return self.start < item < self.end
+    def __getitem__(self, item):
+        return NotImplemented
+    def __len__(self):
+        return NotImplemented
+
+# represents `start..end`
+class ClosedRange(Range):
+    def __contains__(self, item):
+        return self.start <= item <= self.end
+    def __getitem__(self, item):
+        return NotImplemented
+    def __len__(self):
+        return NotImplemented
+
+class RangeIterator:
+    def __init__(self, rng):
+        self.rng = rng
+        self.needle = self.rng.start
+        if type(self.rng.start) == int:
+            if not(self.needle in self.rng):
+                self.needle += 1
+        elif type(self.rng.start) == str:
+            if not(self.needle in self.rng):
+                self.needle = chr(ord(self.needle) + 1)
+        else:
+            if not(self.needle in self.rng):
+                self.needle = self.needle.incremented()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if type(self.rng.start) == int:
+            if self.needle in self.rng:
+                result = self.needle
+                self.needle += 1
+                return result
+        elif type(self.rng.start) == str:
+            if self.needle in self.rng:
+                result = self.needle
+                self.needle = chr(ord(self.needle) + 1)
+                return result
+        else:
+            if self.needle in self.rng:
+                result = self.needle
+                self.needle = self.needle.incremented()
+                return result
+        raise StopIteration
+
+Iterator.register(RangeIterator)

compiler/erg_compiler/lib/std/_prelude.er

@@ -0,0 +1,82 @@
+@Attach NeImpl
+Eq(R := Self) = Trait {
+    .`==` = (self: Self, R) -> Bool
+}
+
+NeImpl R = Patch Eq R
+NeImpl(R).
+    `!=`(self, other: R): Bool = not(self == other)
+
+@Attach EqImpl, LeImpl, LtImpl, GeImpl, GtImpl
+PartialOrd(R := Self) = Trait {
+    .cmp = (self: Self, R) -> Option Ordering
+}
+Ord = Subsume PartialOrd()
+
+EqForOrd R = Patch Ord, Impl := Eq()
+EqForOrd(R).
+    `==`(self, other: R): Bool = self.cmp(other) == Ordering.Equal
+
+LeForOrd = Patch Ord
+LeForOrd.
+    `<=`(self, other: Self): Bool = self.cmp(other) == Ordering.Less or self == other
+LtForOrd = Patch Ord
+LtForOrd.
+    `<`(self, other: Self): Bool = self.cmp(other) == Ordering.Less
+GeForOrd = Patch Ord
+GeForOrd.
+    `>=`(self, other: Self): Bool = self.cmp(other) == Ordering.Greater or self == other
+GtForOrd = Patch Ord
+GtForOrd.
+    `>`(self, other: Self): Bool = self.cmp(other) == Ordering.Greater
+
+Add(R := Self) = Trait {
+    .Output = Type
+    .`_+_` = (self: Self, R) -> Self.Output
+}
+Sub(R := Self) = Trait {
+    .Output = Type
+    .`_-_` = (self: Self, R) -> Self.Output
+}
+Mul(R := Self()) = Trait {
+    .Output = Type
+    .`*` = (self: Self, R) -> Self.Output
+}
+Div(R := Self) = Trait {
+    .Output = Type
+    .`/` = (self: Self, R) -> Self.Output or Panic
+}
+Num: (R := Type) -> Type
+Num = Add and Sub and Mul
+
+Seq T = Trait {
+    .__len__ = (self: Ref(Self)) -> Nat
+    .get = (self: Ref(Self), Nat) -> T
+}
+
+`_+_`: |R: Type, A <: Add(R)| (A, R) -> A.AddO
+`_-_`: |R: Type, S <: Add(R)| (S, R) -> S.SubO
+`*`: |R, O: Type, M <: Add(R)| (M, R) -> M.MulO
+`/`: |R, O: Type, D <: Add(R)| (D, R) -> D.DivO
+
+AddForInt = Patch Int, Impl := Add()
+AddForInt.AddO = Int
+AddForInt.
+    `_+_`: (self: Self, other: Int) -> Int = magic("Add.`_+_`")
+
+# TODO: Mul and Div
+NumForInterval M, N, O, P: Int =
+    Patch M..N, Impl := Add(R := O..P) and Sub(R := O..P)
+NumForInterval(M, N, O, P).
+    `_+_`: (self: Self, other: O..P) -> M+O..N+P = magic("NumForInterval.`_+_`")
+    `_-_`: (self: Self, other: O..P) -> M-P..N-O = magic("NumForInterval.`_-_`")
+
+Read = Trait {
+    .read = (self: Ref(Self)) -> Str
+}
+Read! = Trait {
+    .read! = (self: Ref!(Self)) => Str
+}
+Write! = Trait {
+    .write! = (self: Ref!(Self), Str) => ()
+}

compiler/erg_compiler/lib/std/prelude.er

@@ -0,0 +1,13 @@
+discard _x = None
+
+discard 1
+
+# if: |T, U|(Bool, T, U) -> T or U
+cond|T: Type|(c: Bool, then: T, else: T): T =
+    if c:
+        do then
+        do else
+
+assert cond(False, 1, 2) == 2
+# assert cond(True, 1, 3) == "a"
+# assert "a" == cond(True, 1, 3)