Make std.iter.Stream an inline type

Since this type just wraps a closure there's no need to heap allocate
it.

Changelog: performance

Author: yorickpeterse

std/src/std/iter.inko

@@ -679,17 +679,17 @@ trait pub IntoIter[T] {
 #   nums.next # => Option.Some(1)
 # }
 # ```
-type pub Stream[T] {
+type pub inline Stream[T] {
   let @func: fn -> Option[T]
 
   # Returns a new iterator using the closure.
-  fn pub static new(func: fn -> Option[T]) -> Stream[T] {
+  fn pub inline static new(func: fn -> Option[T]) -> Stream[T] {
     Stream(func)
   }
 }
 
 impl Iter[T] for Stream {
-  fn pub mut next -> Option[T] {
+  fn pub inline mut next -> Option[T] {
     @func.call
   }
 }

std/src/std/range.inko

@@ -24,7 +24,7 @@ import std.clone (Clone)
 import std.cmp (Contains, Equal)
 import std.fmt (Format, Formatter)
 import std.hash (Hash, Hasher)
-import std.iter (Iter, Stream)
+import std.iter (Stream)
 
 # A range of integers.
 trait pub Range: Contains[Int] + Hash + Format {
@@ -41,10 +41,10 @@ trait pub Range: Contains[Int] + Hash + Format {
   fn pub size -> Int
 
   # Returns an iterator over the values in `self`.
-  fn pub iter -> Iter[Int]
+  fn pub iter -> Stream[Int]
 
   # Moves `self` into an iterator.
-  fn pub move into_iter -> Iter[Int] {
+  fn pub move into_iter -> Stream[Int] {
     iter
   }
 }

std/src/std/string.inko

@@ -172,7 +172,7 @@ trait pub Bytes {
   fn pub byte(index: Int) -> Int
 
   # Returns an iterator over the bytes in `self`.
-  fn pub bytes -> Iter[Int]
+  fn pub bytes -> Stream[Int]
 
   # Returns the number of bytes in `self`.
   fn pub size -> Int