closer to making work

Author: alex-s168

PLATFORM/C/LIB/collections.lsts

@@ -2,20 +2,20 @@
 interface Collection<t> {
    let .length(self: Collection<t>): U64;
    let $"[]"(self: Collection<t>, idx: U64): t;
-};
+}
 
 interface Iterator<t> {
    let .next(self: Iterator<t>[]): Maybe<t>;
-};
+}
 
 interface Iterable<t> {
    let .iter(self: Iterable<t>): Iterator<t>;
    let .unsafe-iter(self: Iterable<t>): Iterator<t>;
-};
+}
 
 interface IteratorRemaining {
    let .remaining(self: IteratorRemaining+Iterator<t>): U64;
-};
+}
 
 let remaining-or-zero(from: Iterator<t>): U64 = (
    0
@@ -61,7 +61,13 @@ let .skip(self: Iterator<t>, num: U64): Iterator<t> = (
    self
 );
 
-type RangeIter = RangeIter { let i: U64, len: U64, step: U64 };
+type RangeIter = RangeIter { i: U64, len: U64, step: U64 };
+type RangeIter => Iterable<U64>;
+type RangeIter => IteratorRemaining;
+
+let .remaining(self: RangeIter): U64 = (
+   (self.len - self.i) / self.step
+);
 
 let .next(vp: RangeIter[]): Maybe<U64> = (
    let v = open(vp);
@@ -85,6 +91,12 @@ let range(len: U64): RangeIter = (
 );
 
 type SkipIterator<i+Iterator<t>> = SkipIterator { ii: i, to_skip: U64 };
+type SkipIterator<i+Iterator<t>> => Iterator<t>;
+type SkipIterator<i+Iterator<t>+IteratorRemaining> => IteratorRemaining;
+
+let .remaining(self: SkipIterator<i+Iterator<t>+IteratorRemaining>): U64 = (
+   self.ii.remaining() - self.to_skip
+);
 
 let .skip(iter: i+Iterator<t>, amount: U64): SkipIterator<i> = (
    SkipIterator { iter.ii, iter.to_skip + amount }
@@ -102,6 +114,12 @@ let .next(vp: SkipIterator<i+Iterator<t>>[]): Maybe<t> = (
 );
 
 type LimitIterator<i+Iterator<t>> = LimitIterator { ii: i, idx: U64, limit: U64 };
+type LimitIterator<Iterator<t>> => Iterator<t>;
+type LimitIterator<Iterator<t>> => IteratorRemaining;
+
+let .remaining(self: LimitIterator<t>): U64 = (
+   self.limit - self.idx
+);
 
 let .next(vp: LimitIterator<i+Iterator<t>>[]): Maybe<t> = (
    let v = open(vp);
@@ -121,6 +139,12 @@ let .limit(iter: i+Iterator<t>, amount: U64): LimitIterator<i> = (
 );
 
 type ZipIterator<ai+Iterator<at>, bi+Iterator<bt>> = ZipIterator { aii: ai, bii: bi };
+type ZipIterator<Iterator<at>, Iterator<bt>> => Iterator<Tuple<at,bt>>;
+type ZipIterator<Iterator<at>+IteratorRemaining, Iterator<bt>+IteratorRemaining> => IteratorRemaining;
+
+let .remaining(self: ZipIterator<Iterator<at>+IteratorRemaining, Iterator<bt>+IteratorRemaining>): U64 = (
+   min(self.aii.remaining(), self.bii.remaining())
+);
 
 let .next(p: ZipIterator<ai+Iterator<at>, bi+Iterator<bt>>[]): Maybe<Tuple<at,bt>> = (
    let v = open(p);
@@ -138,13 +162,19 @@ let .next(p: ZipIterator<ai+Iterator<at>, bi+Iterator<bt>>[]): Maybe<Tuple<at,bt
    res
 );
 
-let .zip(ai+Iterator<at>, bi+Iterator<bt>): ZipIterator<ai,bi> = (
+let .zip(ai: Iterator<at>, bi: Iterator<bt>): ZipIterator<ai,bi> = (
    ZipIterator { ai, bi }
 );
 
 type EnumerateIterator<i+Iterator<t>> = EnumerateIterator { ii: i, idx: U64 };
+type EnumerateIterator<Iterator<t>> => Iterator<Tuple<U64,t>>;
+type EnumerateIterator<Iterator<t>+IteratorRemaining> => IteratorRemaining;
+
+let .remaining(self: EnumerateIterator<Iterator<t>+IteratorRemaining>): U64 = (
+   self.ii.remaining()
+);
 
-let .next(p: EnumerateIterator<i+Iterator<t>>[]): Maybe<Tuple<U64, i>> = (
+let .next(p: EnumerateIterator<i+Iterator<t>>[]): Maybe<Tuple<U64, t>> = (
    let v = open(p);
    let iv = (&v.ii).next();
 
@@ -165,10 +195,34 @@ let .next(p: EnumerateIterator<i+Iterator<t>>[]): Maybe<Tuple<U64, i>> = (
    res
 );
 
-let .enumerate(i+Iterator<t>): EnumerateIterator<i> = (
+let .enumerate(i: Iterator<t>): EnumerateIterator<i> = (
    EnumerateIterator { i, 0_u64 }
 );
 
+type CollectionIteratorBase<c+Collection<t>> = CollectionIteratorBase { coll: c, idx: U64 };
+type CollectionIteratorBase<c+Collection<t>> => Iterator<t>;
+type CollectionIteratorBase<c+Collection<t>> => IteratorRemaining;
+
+let .remaining(self: CollectionIteratorBase<c+Collection<t>>): U64 = (
+   self.coll.length() - self.idx
+);
+
+let .skip(self: CollectionIteratorBase<c>, num: U64): CollectionIteratorBase<c> = (
+   CollectionIteratorBase { self.coll, self.idx + num }
+);
+
+let .next(p: CollectionIteratorBase<c+Collection<t>>[]): Maybe<t> = (
+   let v = p[0];
+   if v.idx < v.coll.length() {
+      let val = v.coll[v.idx];
+      v.idx = v.idx + 1;
+      p[0] = v;
+      Some { val } :: Maybe<t>
+   } else {
+      None :: Maybe<t>
+   }
+);
+
 let cmp(ls: Collection<a>, rs: Collection<b>): Ord = (
    let diff = Equal;
 
@@ -199,7 +253,7 @@ let .contains(self: Iterable<t>, value: t): U64 = (
    ok
 );
 
-# TODO: generic Collection<t> impl for Iterable<t>
+# TODO: generic Collection<t> impl for Iterable<t> ?
 
 let .has-prefix-at(self: Iterable<t>, off: U64, seq: Iterable<t>): Bool = (
    if (self.length() - off) < seq.length() {
@@ -369,7 +423,7 @@ let .collect(x: Iterator<t>): Vector<t> = (
 
 type SplitWithIndentIter<t,sp,uv,dv> = SplitWithIndentIter { data: Vector<t>, split: sp, up: Vector<uv>, down: Vector<dv> };
 
-let .next(vp: SplitWithIndentIter<t,sp,uv,dv>[]): Maybe<Vector<t>> => (
+let .next(vp: SplitWithIndentIter<t,sp,uv,dv>[]): Maybe<Vector<t>> = (
    let v = open(vp);
 
    if v.data.length() > 0 {
@@ -424,7 +478,7 @@ let .repeat(self: Iterable<t>, times: U64): Vector<t> = (
    while times > 0 {
       for x in self {
          out = out.push(x);
-      }
+      };
       times = times - 1;
    };
    out
@@ -489,3 +543,5 @@ let .pad-right(self: Iterable<t>, value: t, minlen: U64): Vector<t> = (
 
    out
 );
+
+# TODO: OnceIterable (from iterator)

PLATFORM/C/LIB/hashtable.lsts

@@ -2,6 +2,8 @@
 type HashtableEq<k,v> = HashtableEq { occupied: U64, capacity: U64, contents: Tuple<k,v>[] }
                       | HashtableEqEOF;
 
+type HashtableEq<k,v> => Iterable<Tuple<k,v>>;
+
 let .clone(self: HashtableEq<k,v>): HashtableEq<k,v> = (
    match self {
       HashtableEq { occupied=occupied } => (
@@ -23,6 +25,7 @@ let .clone(self: HashtableEq<k,v>): HashtableEq<k,v> = (
 );
 
 type HashtableEqIter<k,v> = HashtableEqIter { table: HashtableEq<k,v>, idx: U64 };
+type HashtableEqIter<k,v> => Iterator<Tuple<k,v>>;
 
 # for safety, we clone the table
 # All modifications done to the vector after creating the iterator will not be seen

PLATFORM/C/LIB/list.lsts

@@ -1,4 +1,7 @@
 
+type List<x> => Iterable<x>;
+type List<x> => Collection<x>;
+
 let $"[]"(tt: List<x>, idx: U64): x = (
    while idx > 0 {
       if not(tt.has-head()) {
@@ -19,12 +22,13 @@ let .unique(ls: List<x>): List<x> = (
    rs
 );
 
-type ListIter<x> = ListIter { list: List<x> }
+type ListIter<x> = ListIter { list: List<x> };
+type ListIter<x> => Iterator<x>;
 
 let .next(ls: ListIter<x>[]): Maybe<x> = (
    match open(ls.list) {
       [i.. rst] => (
-         ls[0_u64].list = rst;
+         ls[0].list = rst;
          Some(i)
       );
       [] => (None :: Maybe<x>);

PLATFORM/C/LIB/serial.lsts

@@ -10,11 +10,14 @@ type SerialVal = SerialUInt { val: U64 }
 
 interface Serializable {
    let serialize(self: Serializable): SerialVal;
-};
+}
 
 interface Deserializable {
    let deserialize(val: SerialVal, ty: Type<Deserializable>): Deserializable;
-};
+}
+
+type SerialVal => Serializable;
+type SerialVal => Deserializable;
 
 let deserialize(val: SerialVal, ty: Type<SerialVal>): SerialVal = (
    val
@@ -24,6 +27,9 @@ let serialize(val: SerialVal): SerialVal = (
    val
 );
 
+type Bool => Serializable;
+type Bool => Deserializable;
+
 let deserialize(vali: SerialVal, ty: Type<Bool>): Bool = (
    deserialize(vali,type(U64)) as Bool
 );
@@ -32,6 +38,9 @@ let serialize(val: Bool): SerialVal = (
    SerialBool { val }
 );
 
+type U64 => Serializable;
+type U64 => Deserializable;
+
 let deserialize(vali: SerialVal, ty: Type<U64>): U64 = (
    match vali {
       SerialBool { val=val } => ( val as U64 );
@@ -60,6 +69,9 @@ let serialize(val: U64): SerialVal = (
    SerialUInt { val }
 );
 
+type I64 => Serializable;
+type I64 => Deserializable;
+
 let deserialize(vali: SerialVal, ty: Type<I64>): I64 = (
    match vali {
       SerialBool { val=val } => ( val as I64 );
@@ -80,6 +92,9 @@ let serialize(val: I64): SerialVal = (
    SerialInt { val }
 );
 
+type F64 => Serializable;
+type F64 => Deserializable;
+
 let deserialize(vali: SerialVal, ty: Type<F64>): F64 = (
    match vali {
       SerialBool { val=val } => ( val as F64 );
@@ -95,6 +110,9 @@ let serialize(val: F64): SerialVal = (
    SerialFlt { val }
 );
 
+type String => Serializable;
+type String => Deserializable;
+
 let deserialize(vali: SerialVal, ty: Type<String>): String = (
    match vali {
       SerialStr  { val=val } => ( val );
@@ -106,6 +124,9 @@ let serialize(val: String): SerialVal = (
    SerialStr { val }
 );
 
+type CString => Serializable;
+type CString => Deserializable;
+
 let deserialize(vali: SerialVal, ty: Type<CString>): CString = (
    match vali {
       SerialStr  { val=val } => ( untern(val) );
@@ -117,6 +138,9 @@ let serialize(val: CString): SerialVal = (
    SerialStr { (to-smart-string(val)) }
 );
 
+type Iterable<Serializable> => Serializable;
+type FromVector<Deserializable> => Deserializable;
+
 let deserialize(vali: SerialVal, ty: Type<ot+FromVector<eltt+Deserializable>>): ot = (
    match vali {
       SerialVec { val=val } => (
@@ -138,6 +162,9 @@ let serialize(self: Iterable<t+Serializable>): SerialVal = (
    SerialVec { out }
 );
 
+type HashtableEq<Serializable,Serializable> => Serializable;
+type HashtableEq<Deserializable,Deserializable> => Deserializable;
+
 let deserialize(val: SerialVal, ty: Type<HashtableEq<k+Deserializable,v+Deserializable>>): HashtableEq<k,v> = (
    let out = {} :: HashtableEq<k,v>;
    match val {

PLATFORM/C/LIB/smart-string.lsts

@@ -1,4 +1,15 @@
 
+type SmartString => Collection<U8>;
+type SmartString => Iterable<U8>;
+
+let .iter(self: SmartString): CollectionIteratorBase<SmartString> = (
+   CollectionIteratorBase { self, 0 }
+);
+
+let .unsafe-iter(self: SmartString): CollectionIteratorBase<SmartString> = (
+   self.iter()
+);
+
 let cmp(l: CString, r: String): Ord = (
    cmp( intern(l), r )
 );
@@ -82,7 +93,8 @@ let .count-right-spaces(self: String): U64 = (
 
 let .trim-right(self: String): String = (
    while self.length() > 0 && self.last().is-space() {
-      self = self[:(self.length()-1)];
+      let l = self.length() - 1;
+      self = self[:l];
    };
    self
 );

PLATFORM/C/LIB/string.lsts

@@ -1,4 +1,7 @@
 
+type CString => Iterable<U8>;
+type CString => Collection<U8>;
+
 # TODO: instead do U8 iterator for S
 
 let clone-rope(s: S): CString = (
@@ -26,6 +29,7 @@ let clone-rope-impl(s: S, out: Vector<U8>): Vector<U8> = (
 );
 
 type CStringIter = CStringIter { ptr: CString };
+type CStringIter => Iterator<U8>;
 
 let .next(self: CStringIter[]): U8 = (
    let val = open(self).ptr[0];

PLATFORM/C/LIB/u8.lsts

@@ -38,5 +38,5 @@ let to-smart-string(i: U8): String = (
 );
 
 let .is-space(self: U8): U64 = (
-   (self >= 1) && (self <= 40)) || (self == 177)
+   ((self >= 1) && (self <= 40)) || (self == 177)
 );

PLATFORM/C/LIB/umbra.lsts

@@ -37,6 +37,9 @@ type UmbraShortLong = UmbraShort { arr: U8[12] } | UmbraLong { prefix: U8[4], pt
 
 type Umbra = Umbra { len: U32, backing: UmbraShortLong };
 
+type Umbra => Collection<U8>;
+type Umbra => Iterable<U8>;
+
 let .length(s: Umbra[]): U64 = (
     s.len as U64
 );
@@ -255,28 +258,11 @@ let $"+"(l: Umbra[], r: t): Umbra = (
     concat-to-umbra(l, r)
 );
 
-let .iter(self: Umbra): UmbraIter = (
-    to-umbra(self).unsafe-iter();
+let .iter(self: Umbra): CollectionIteratorBase<Umbra> = (
+   to-umbra(self).unsafe-iter()
 );
 
-let .unsafe-iter(self: Umbra): UmbraIter = (
-    UmbraIter { self, 0 }
+let .unsafe-iter(self: Umbra): CollectionIteratorBase<Umbra> = (
+   CollectionIteratorBase { self, 0 }
 );
 
-type UmbraIter = UmbraIter { str: Umbra, idx: U64 };
-
-let .skip(v: UmbraIter, amount: U64): UmbraIter = (
-   UmbraIter { v, v.idx + amount }
-);
-
-let .next(vp: UmbraIter[]): Maybe<U8> = (
-   let v = open(vp);
-   if v.idx >= v.str.length {
-      None :: Maybe<u8>
-   } else {
-      let val = v.str[v.idx];
-      v.idx = v.idx + 1;
-      vp[0] = v;
-      Some { val }
-   }
-);