generics.ve

class Unit {
   -+value : unit;
   
   +equals(b : Object) : bool {
      true
   }
   
   +code() : int32 {
      0
   }
}

class Bool {
   -+value : bool;
   
   +equals(b : Object) : bool {
      let b2 : Bool <- b<Bool> in
         if value = b2.value then
            true
         else
            false
   }
   
   +code() : int32 {
      if value then
         1
      else
         0
   }
}

class Byte {
   -+value : byte;
   
   +toBool() : bool {
      if value = 0 then
         false
      else
         true
   }
   
   +equals(b : Object) : bool {
      let b2 : Byte <- b<Byte> in
         if value = b2.value then
            true
         else
            false
   }
}

class Integer {
   -+value : int32;
   
   +toBool() : bool {
      if value = 0 then
         false
      else
         true
   }
   
   +equals(b : Object) : bool {
      let b2 : Integer <- b<Integer> in
         if value = b2.value then
            true
         else
            false
   }
   
   +code() : int32 {
      value
   }
}

class Float {
   -+value : float;
   
   +code() : int32 {
      @value
   }
}

class String {
   -len : int32;
   -rsize : int32;
   -value : string;
   
   +getValue() : string { value }
   
   +setValue(s : string) : String {
      value <- s;
      len <- size();
      rsize <- len;
      self
   }
   
   +equals(b : Object) : bool {
      //This is actually never evaluated, replaced by compiler
      false
   }
   
   -size() : int32 {
      //This is actually never evaluated, replaced by compiler
      0
   }
   
   +a(s : string) : String {
      //This is actually never evaluated, replaced by compiler
      self
   }
   
   +asciiAt(i : int32) : int32 {
      //This is actually never evaluated, replaced by compiler
      0
   }
   
   +code() : int32 {
      //This is actually never evaluated, replaced by compiler
      0
   }
   
   +length() : int32 {
      len
   }
   
}

class Task {
   +run(o : Object) : unit { () }
   +accept(o : Object) : bool { true }
}

class Array extends IO {
   -len : int32;
   -values : Object[];
   
   +init(l : int32) : Array {
      len <- l;
      values <- new Object[len];
      self
   }
   
   +get(i : int32) : Object {
      if i < len then
         values[i]
      else {
         print("Runtime array index out of bounds\n");
         null
      }
   }
   
   +set(i : int32, o : Object) : Array {
      if i < len then {
         values[i] <- o;
         ()
      } else {
         print("Runtime array index out of bounds\n");
         ()
      };
      self
   }
   
   +size() : int32 {
      len
   }
   
   +map(t : Task) : unit {
      for n : values : len do
         t.run(n);
      ()
   }
   
   +filter(t : Task) : Array {
      let r : Array <- new Array(len), w : int32 <- 0 in {
         for n : values : len do {
            if t.accept(n) then {
               r.values[w] <- n;
               w <- w + 1
            }
         };
         r.len <- w;
         r
      }
   }
   
   +dumpAsIntArray() : Array {
      for n : values : len do
         printInt32(n<Integer>).print("\n");
      self
   }
}