refactor: update function signatures to use StringView instead of @string.View for improved consistency and clarity

Author: bobzhang

string/regex/README.mbt.md

@@ -26,8 +26,8 @@ test {
   // Write a simple split with regexp
   fn split(
     regexp : @regex.Regex,
-    target : @string.View,
-  ) -> Array[@string.View] {
+    target : StringView,
+  ) -> Array[StringView] {
     let result = []
     for str = target {
       match regexp.execute(str) {
@@ -63,9 +63,9 @@ test {
 
 ### Inspect Results
 
-- `result.content()` → `@string.View`
-- `result.before()` → `@string.View`
-- `result.after()` → `@string.View`
+- `result.content()` → `StringView`
+- `result.before()` → `StringView`
+- `result.after()` → `StringView`
 - `result.group(index)` → Capture group content
 - `result.named_group(name)` → Named capture group content
 

string/regex/internal/regex_impl/chars.mbt

@@ -84,7 +84,7 @@ test "ordered range" {
 
 ///|
 /// TODO: consider unicode mode
-fn is_word_char_at(input : @string.View, sp : Int) -> Bool {
+fn is_word_char_at(input : StringView, sp : Int) -> Bool {
   if sp == -1 || sp == input.length() {
     return false
   }

string/regex/internal/regex_impl/impl.mbt

@@ -54,7 +54,7 @@ priv struct Thread {
 /// @param thread the current thread to add  
 /// @param clist the list of threads to be processed in the next iteration  
 fn add_thread(
-  content : @string.View,
+  content : StringView,
   instructions : Array[Instruction],
   inst_gen : Array[Int],
   thread : Thread,
@@ -136,7 +136,7 @@ fn add_thread(
 /// @return an array of integers representing the start and end indices of the matches, or an empty array if no match is found
 fn vm(
   instructions : Array[Instruction],
-  input : @string.View,
+  input : StringView,
   captures : Int,
   allow_exponentiaion? : Bool = false,
 ) -> Array[Int] {

string/regex/internal/regex_impl/parse.mbt

@@ -69,7 +69,7 @@
 
 ///|
 priv struct Parser {
-  mut input : @string.View
+  mut input : StringView
   mut flags : Flags
   mut captures : Int
   current_capture_scope : @set.Set[Int]
@@ -113,7 +113,7 @@ pub enum Err {
 ///
 /// Contains error information and related string view context
 pub suberror RegexpError {
-  RegexpError(err~ : Err, source_fragment~ : @string.View)
+  RegexpError(err~ : Err, source_fragment~ : StringView)
 } derive(Show)
 
 ///|
@@ -123,7 +123,7 @@ pub suberror RegexpError {
 /// - `input`: String view of the regular expression to parse
 ///
 /// Returns: New parser instance
-fn Parser::new(input : @string.View, flags : Flags) -> Parser {
+fn Parser::new(input : StringView, flags : Flags) -> Parser {
   Parser::{
     input,
     flags,
@@ -145,7 +145,7 @@ fn Parser::new(input : @string.View, flags : Flags) -> Parser {
 ///
 /// Throws: Error_ when parsing fails
 fn parse(
-  regex : @string.View,
+  regex : StringView,
   flags? : Flags = Flags::default(),
 ) -> ParseResult raise RegexpError {
   let parser = Parser::new(regex, flags)

string/regex/internal/regex_impl/top.mbt

@@ -33,8 +33,8 @@
 /// ))
 /// ```
 pub fn compile(
-  regexp : @string.View,
-  flags? : @string.View = "",
+  regexp : StringView,
+  flags? : StringView = "",
 ) -> Regexp raise RegexpError {
   regexp
   |> parse(flags={
@@ -131,7 +131,7 @@ pub fn Regexp::group_names(self : Regexp) -> Array[String] {
 ///   ))
 /// }
 /// ```
-pub fn Regexp::execute(self : Regexp, input : @string.View) -> MatchResult {
+pub fn Regexp::execute(self : Regexp, input : StringView) -> MatchResult {
   let captures = vm(self.instructions, input, self.capture)
   let (before, after) = if captures is [0..<_ as start, 0..<_ as end, ..] {
     (input.view(end_offset=start), input.view(start_offset=end))
@@ -154,7 +154,7 @@ pub fn Regexp::execute(self : Regexp, input : @string.View) -> MatchResult {
 /// 
 /// Returns: A tuple of 
 /// - `MatchResult` object containing the match status and capture group information.
-/// - `@string.View` representing the remaining text after the match.
+/// - `StringView` representing the remaining text after the match.
 /// 
 /// Example:
 /// ```moonbit
@@ -171,8 +171,8 @@ pub fn Regexp::execute(self : Regexp, input : @string.View) -> MatchResult {
 #deprecated("Use `Regexp::execute` and `MatchResult::before`/`after` instead.")
 pub fn Regexp::execute_with_remainder(
   self : Regexp,
-  input : @string.View,
-) -> (MatchResult, @string.View) {
+  input : StringView,
+) -> (MatchResult, StringView) {
   let captures = vm(self.instructions, input, self.capture)
   if captures is [0..<_ as start, 0..<_ as end, ..] {
     (
@@ -220,7 +220,7 @@ pub fn Regexp::execute_with_remainder(
 /// inspect(result.after(), content=("xx"))
 /// assert_true(engine.match_("axxf") is None)
 /// ```
-pub fn Regexp::match_(self : Regexp, input : @string.View) -> MatchResult? {
+pub fn Regexp::match_(self : Regexp, input : StringView) -> MatchResult? {
   let captures = vm(self.instructions, input, self.capture)
   guard captures is [0..<_ as start, 0..<_ as end, ..] else { return None }
   let before = input.view(end_offset=start)
@@ -242,11 +242,11 @@ pub fn Regexp::match_(self : Regexp, input : @string.View) -> MatchResult? {
 /// - Index 4, 5: Start and end positions of the second capture group.
 /// - And so on...
 pub struct MatchResult {
-  input : @string.View
+  input : StringView
   captures : Array[Int]
   names : Map[String, Int]
-  before : @string.View
-  after : @string.View
+  before : StringView
+  after : StringView
 }
 
 ///|
@@ -294,7 +294,7 @@ pub fn MatchResult::matched(self : Self) -> Bool {
 ///   #|Some("bc")
 /// ))
 /// ```
-pub fn MatchResult::get(self : Self, index : Int) -> @string.View? {
+pub fn MatchResult::get(self : Self, index : Int) -> StringView? {
   if self.captures.is_empty() ||
     index < 0 ||
     index >= self.captures.length() / 2 {
@@ -331,7 +331,7 @@ pub fn MatchResult::get(self : Self, index : Int) -> @string.View? {
 /// ))
 /// ```
 ///
-pub fn MatchResult::groups(self : Self) -> Map[String, @string.View] {
+pub fn MatchResult::groups(self : Self) -> Map[String, StringView] {
   self.names
   .iter()
   .filter_map(p => if self.get(p.1) is Some(content) {
@@ -361,7 +361,7 @@ pub fn MatchResult::groups(self : Self) -> Map[String, @string.View] {
 ///   #|[Some("abc"), Some("c")]
 /// ))
 /// ```
-pub fn MatchResult::results(self : Self) -> Array[@string.View?] {
+pub fn MatchResult::results(self : Self) -> Array[StringView?] {
   let results = []
   for i = 0; i < self.captures.length() / 2; i = i + 1 {
     let start = self.captures[i * 2]
@@ -387,7 +387,7 @@ pub fn MatchResult::results(self : Self) -> Array[@string.View?] {
 /// let result = engine.execute("say hello")
 /// inspect(result.before(), content="say hello")
 /// ```
-pub fn MatchResult::before(self : Self) -> @string.View {
+pub fn MatchResult::before(self : Self) -> StringView {
   self.before
 }
 
@@ -403,7 +403,7 @@ pub fn MatchResult::before(self : Self) -> @string.View {
 /// let result = engine.execute("say yes")
 /// inspect(result.after(), content="")
 /// ```
-pub fn MatchResult::after(self : Self) -> @string.View {
+pub fn MatchResult::after(self : Self) -> StringView {
   self.after
 }
 
@@ -455,7 +455,7 @@ test "rest method with capture groups" {
 ///|
 test "rest method usage example" {
   let engine = compile("\\b\\w+\\b")
-  let mut input : @string.View = "word1 word2 word3"
+  let mut input : StringView = "word1 word2 word3"
   let (result1, rest1) = engine.execute_with_remainder(input)
   inspect(
     result1.get(0),

string/regex/regex.mbt

@@ -18,31 +18,31 @@ struct MatchResult(@regex_impl.MatchResult)
 
 ///|
 #internal(experimental, "subject to breaking change without notice")
-pub fn MatchResult::before(self : Self) -> @string.View {
+pub fn MatchResult::before(self : Self) -> StringView {
   self.0.before()
 }
 
 ///|
 #internal(experimental, "subject to breaking change without notice")
-pub fn MatchResult::after(self : Self) -> @string.View {
+pub fn MatchResult::after(self : Self) -> StringView {
   self.0.after()
 }
 
 ///|
 #internal(experimental, "subject to breaking change without notice")
-pub fn MatchResult::content(self : Self) -> @string.View {
+pub fn MatchResult::content(self : Self) -> StringView {
   self.0.get(0).unwrap()
 }
 
 ///|
 #internal(experimental, "subject to breaking change without notice")
-pub fn MatchResult::group(self : Self, index : Int) -> @string.View? {
+pub fn MatchResult::group(self : Self, index : Int) -> StringView? {
   self.0.get(index)
 }
 
 ///|
 #internal(experimental, "subject to breaking change without notice")
-pub fn MatchResult::named_group(self : Self, name : String) -> @string.View? {
+pub fn MatchResult::named_group(self : Self, name : String) -> StringView? {
   guard self.0.names.get(name) is Some(index) else { None }
   self.0.get(index)
 }
@@ -53,13 +53,13 @@ struct Regex(@regex_impl.Regexp)
 
 ///|
 #internal(experimental, "subject to breaking change without notice")
-pub fn compile(pattern : @string.View) -> Regex raise {
+pub fn compile(pattern : StringView) -> Regex raise {
   @regex_impl.compile(pattern)
 }
 
 ///|
 #internal(experimental, "subject to breaking change without notice")
-pub fn Regex::execute(self : Self, input : @string.View) -> MatchResult? {
+pub fn Regex::execute(self : Self, input : StringView) -> MatchResult? {
   match self.0.match_(input) {
     None => None
     Some(result) => Some(MatchResult(result))