string.vek

builtin string {
  pub fn to_cstr(self) -> cstr;
  pub unsafe fn from_cstr(source: cstr) -> string;

  pub inline fn is_empty(self) -> bool {
    return self.length() == 0;
  }

  pub fn starts_with(self, prefix: string) -> bool {
    if prefix.length() > self.length() {
      return false;
    }
    let mut i: usize = 0;
    while i < prefix.length() {
      if !self[i].equals(prefix[i]) {
        return false;
      }
      i += 1;
    }
    return true;
  }

  pub fn ends_with(self, suffix: string) -> bool {
    if suffix.length() > self.length() {
      return false;
    }
    let offset: usize = self.length() - suffix.length();
    let mut i: usize = 0;
    while i < suffix.length() {
      if !self[offset + i].equals(suffix[i]) {
        return false;
      }
      i += 1;
    }
    return true;
  }

  pub fn contains(self, needle: string) -> bool {
    if needle.length() > self.length() {
      return false;
    }
    if needle.length() == 0 {
      return true;
    }
    let limit: usize = self.length() - needle.length() + 1;
    let mut i: usize = 0;
    while i < limit {
      let mut j: usize = 0;
      let mut matched: bool = true;
      while j < needle.length() {
        if !self[i + j].equals(needle[j]) {
          matched = false;
          break;
        }
        j += 1;
      }
      if matched {
        return true;
      }
      i += 1;
    }
    return false;
  }

  pub fn count(self, needle: string) -> usize {
    if needle.length() == 0 {
      return 0;
    }
    if needle.length() > self.length() {
      return 0;
    }
    let limit: usize = self.length() - needle.length() + 1;
    let mut count: usize = 0;
    let mut i: usize = 0;
    while i < limit {
      let mut j: usize = 0;
      let mut matched: bool = true;
      while j < needle.length() {
        if !self[i + j].equals(needle[j]) {
          matched = false;
          break;
        }
        j += 1;
      }
      if matched {
        count += 1;
        i += needle.length();
      } else {
        i += 1;
      }
    }
    return count;
  }

  pub fn find(self, needle: string) -> usize? {
    if needle.length() == 0 {
      return 0;
    }
    if needle.length() > self.length() {
      return null;
    }
    let limit: usize = self.length() - needle.length() + 1;
    let mut i: usize = 0;
    while i < limit {
      let mut j: usize = 0;
      let mut matched: bool = true;
      while j < needle.length() {
        if !self[i + j].equals(needle[j]) {
          matched = false;
          break;
        }
        j += 1;
      }
      if matched {
        return i;
      }
      i += 1;
    }
    return null;
  }

  pub fn replace(mut self, needle: string, replacement: string, amount: usize? = null) -> usize {
    if needle.length() == 0 {
      return 0;
    }
    if needle.length() > self.length() {
      return 0;
    }
    if amount != null && amount == 0 {
      return 0;
    }
    let len: usize = self.length();
    let needle_len: usize = needle.length();
    let mut result: string = "";
    let mut count: usize = 0;
    let mut i: usize = 0;
    while i < len {
      let mut matched: bool = false;
      if i + needle_len <= len && (amount == null || count < amount) {
        let mut j: usize = 0;
        matched = true;
        while j < needle_len {
          if !self[i + j].equals(needle[j]) {
            matched = false;
            break;
          }
          j += 1;
        }
      }
      if matched {
        result += replacement;
        count += 1;
        i += needle_len;
      } else {
        result += self[i];
        i += 1;
      }
    }
    self = result;
    return count;
  }

  satisfies Length {
    fn length(self) -> usize;
  }

  satisfies Equal<string> {
    fn equals(self, other: string) -> bool;
  }

  satisfies Order<string> {
    fn compare(self, other: string) -> Ordering;
  }

  satisfies Hash {
    fn hash(self) -> u64;
  }

  satisfies Add<string, string> {
    fn add(self, rhs: string) -> string;
  }

  satisfies Index<usize, string> {
    fn index_get(self, index: usize) -> string;
  }

  satisfies Clone {
    fn clone(self) -> string;
  }

  satisfies Default {
    inline fn default() -> Self {
      return "";
    }
  }

  satisfies Format {
    inline fn format(self) -> string {
      return self.clone();
    }
  }
}