Rename Array::first -> front, last -> back

Named after Godot methods front/back, also consistent with push_front/pop_front.
Interestingly, Rust Vec has first/last, however both VecDeque and LinkedList have
front/back, likely due to efficient insertion and FIFO semantics.

Author: Bromeon

godot-core/src/builtin/array.rs

@@ -133,6 +133,11 @@ impl<T: ArrayElement> Array<T> {
         }
     }
 
+    #[deprecated = "Renamed to `get`."]
+    pub fn try_get(&self, index: usize) -> Option<T> {
+        self.get(index)
+    }
+
     /// Returns `true` if the array contains the given value. Equivalent of `has` in GDScript.
     pub fn contains(&self, value: &T) -> bool {
         self.as_inner().has(value.to_variant())
@@ -172,27 +177,33 @@ impl<T: ArrayElement> Array<T> {
     }
 
     /// Returns the first element in the array, or `None` if the array is empty.
-    ///
-    /// Equivalent of `front()` in GDScript.
-    #[doc(alias = "front")]
-    pub fn first(&self) -> Option<T> {
+    #[doc(alias = "first")]
+    pub fn front(&self) -> Option<T> {
         (!self.is_empty()).then(|| {
             let variant = self.as_inner().front();
             T::from_variant(&variant)
         })
     }
 
     /// Returns the last element in the array, or `None` if the array is empty.
-    ///
-    /// Equivalent of `back()` in GDScript.
-    #[doc(alias = "back")]
-    pub fn last(&self) -> Option<T> {
+    #[doc(alias = "last")]
+    pub fn back(&self) -> Option<T> {
         (!self.is_empty()).then(|| {
             let variant = self.as_inner().back();
             T::from_variant(&variant)
         })
     }
 
+    #[deprecated = "Renamed to `front`, in line with GDScript method and consistent with `push_front` and `pop_front`."]
+    pub fn first(&self) -> Option<T> {
+        self.front()
+    }
+
+    #[deprecated = "Renamed to `back`, in line with GDScript method."]
+    pub fn last(&self) -> Option<T> {
+        self.back()
+    }
+
     /// Clears the array, removing all elements.
     pub fn clear(&mut self) {
         // SAFETY: No new values are written to the array, we only remove values from the array.
@@ -223,7 +234,7 @@ impl<T: ArrayElement> Array<T> {
         unsafe { self.as_inner_mut() }.push_back(value.to_variant());
     }
 
-    /// Adds an element at the beginning of the array, in O(n) time.
+    /// Adds an element at the beginning of the array, in O(n).
     ///
     /// On large arrays, this method is much slower than [`push()`][Self::push], as it will move all the array's elements.
     /// The larger the array, the slower `push_front()` will be.
@@ -243,7 +254,7 @@ impl<T: ArrayElement> Array<T> {
         })
     }
 
-    /// Removes and returns the first element of the array. Returns `None` if the array is empty.
+    /// Removes and returns the first element of the array, in O(n). Returns `None` if the array is empty.
     ///
     /// Note: On large arrays, this method is much slower than `pop()` as it will move all the
     /// array's elements. The larger the array, the slower `pop_front()` will be.

itest/rust/src/builtin_tests/containers/array_test.rs

@@ -187,13 +187,13 @@ fn array_try_get() {
 fn array_first_last() {
     let array = array![1, 2];
 
-    assert_eq!(array.first(), Some(1));
-    assert_eq!(array.last(), Some(2));
+    assert_eq!(array.front(), Some(1));
+    assert_eq!(array.back(), Some(2));
 
     let empty_array = VariantArray::new();
 
-    assert_eq!(empty_array.first(), None);
-    assert_eq!(empty_array.last(), None);
+    assert_eq!(empty_array.front(), None);
+    assert_eq!(empty_array.back(), None);
 }
 
 #[itest]