RFC: Generalized String Iteration

rfcs/generalized-string-iteration.md

@@ -0,0 +1,85 @@
+# Generalized String Iteration
+
+## Summary
+
+Introduce support for iterating over strings without using `string.split`/`gmatch`/`sub` by defining a default `__iter` implementation for strings.
+
+## Motivation
+
+Luau recently introduced an `__iter` metamethod to create a generic iteration fashion for arrays, dictionaries, and custom objects. However, strings were overlooked during the initial implementation of this feature and do not support generalized iteration like other objects.
+
+This proposal allows strings to be supported in generalized iteration for performance enhancement, consistent `__iter` behavior, and easier code for iteration through strings.
+
+## Design
+
+Because `__iter` already exists, implementing this behavior should be very easy. The most simple and proper approach would be to add an `__iter` metamethod to the string metatable that allows iterating through strings as if they are a character array. The current string metatable only consists of an `__index` field that points to the `string` library, and no `__iter` method is defined.
+
+### Behavior
+
+As stated before, the iterator will treat strings as if they are a character array:
+
+```lua
+for position: number, character: string in "Luau" do
+	print(position, character)
+end
+```
+
+Output:
+
+```
+1	L
+2	u
+3	a
+4	u
+```
+
+## Drawbacks
+
+This implementation should have no known drawbacks and checks all the boxes. The behavior follows similar generalized-iteration behavior to other objects. Additionally, many other languages support direct iteration through strings (C#, etc.), so it will be recognizable by those transferring from other languages to Luau. Finally, `__iter` already exists and there is no current `__iter` method for strings.
+
+## Alternatives
+
+This behavior can be implemented in Lua, but there are multiple problems with this:
+1. Code that emulates this behavior is *much* slower than a native C iterator would be.
+2. Code that emulates this behavior is more complicated to write and harder for beginners.
+
+### Lua Implementations
+
+#### 1. string.sub Iteration
+
+```lua
+local myString = "Luau"
+for position = 1, #myString do
+	local character = string.sub(myString, position, position)
+	....
+end
+```
+
+#### 2. string.gmatch Iteration
+
+```lua
+local position = 1
+for character in string.gmatch("Luau", ".") do
+	....
+	position += 1
+end
+```
+
+#### 3. string.split Iteration
+
+```lua
+for position, character in string.split("Luau", "") do 
+	....
+end
+```
+
+### Results
+
+```
+char[]        	0.6009999999998854
+string.sub    	5.2380000000000560
+string.gmatch 	8.6480000000001380
+string.split  	12.916999999999916
+```
+
+In a benchmark of 1,000,000 iterations of the previously listed alternatives versus an iteration over an array of the same characters, the generalized iteration outperformed the Lua implementations in every case. Not only do the alternatives require more potentially unfamiliar syntax & functions, but they also have significantly lower performance. While this benchmark isn\'t perfect, it is still reasonable to assume that a dedicated and optimized C `__iter` method for strings will outperform all alternatives.