fix: a panic case & add some docs

Author: Chronostasys

planglib/std/slice.pi

@@ -9,13 +9,11 @@ pub struct SliceOutOfIdxErr {
 
 }
 
-fn test2<T>() void {
-    
-    return;
-}
-
 use core::eq::Eq;
 impl<T:Eq<T>> SliceExt<T> for [T] {
+    /// # index_of
+    ///
+    /// Find the index of the first occurrence of a sub array in the array.
     fn index_of(sub_arr:[T])  Option<i64> {
         let len = self.len();
         let sub_len = sub_arr.len();
@@ -40,13 +38,23 @@ impl<T:Eq<T>> SliceExt<T> for [T] {
 
     }
 
+    /// # len
+    ///
+    /// Get the length of the array.
     fn len() i64 {
         return arr_len(*self) ;
     }
 
+    /// # slice
+    ///
+    /// Get a slice of the array.
     fn slice(start: i64, len: i64) [T] {
         return arr_slice(*self, start, len);
     }
+
+    /// # copy
+    ///
+    /// Copy the array to another array.
     fn copy(to:[T], len:i64) Result<()|SliceOutOfIdxErr> {
         let from = *self;
         if from.len() < len || to.len() < len {

planglib/std/string.pi

@@ -9,14 +9,29 @@ pub trait StringExt {
 
 
 impl StringExt for string {
+    /// # index_of
+    ///
+    /// Returns the index of the first occurrence of the
+    /// specified substring in this string, or `None` if there is no such occurrence.
     fn index_of(s:string) Option<i64> {
         let chars = self.chars();
         let subchars = s.chars();
         return chars.index_of(subchars);
     }
+    /// # contains
+    ///
+    /// Returns `true` if the specified substring is a
+    /// substring of this string, and `false` otherwise.
     fn contains(s:string) bool {
         return self.index_of(s) is i64;
     }
+
+    /// # slice
+    ///
+    /// Returns a new string that is a substring of this string.
+    ///
+    /// The substring is a slice of the original string starting from the `start` index and
+    /// having `len` characters.
     fn slice(start:i64, len:i64) string {
         if start + len == 0 {
             return "";
@@ -50,7 +65,7 @@ impl StringExt for string {
         }
 
         if byte_len == 0 && len != 0 {
-             pl_panic();
+            pl_panic();
             return string {
                 _len: 0,
                 _byte_len: 0,
@@ -67,6 +82,10 @@ impl StringExt for string {
 
 }
 
+
+/// # from_chars
+/// 
+/// Converts a list of characters to a string.
 pub fn from_chars(chars:[char]) string {
     let bytes:[u8] = [u8*4*arr_len(chars);];
     let i = 0;

src/ast/ctx.rs

@@ -1213,7 +1213,7 @@ impl<'a, 'ctx> Ctx<'a> {
         let binding = l
             .trait_impl
             .clone()
-            .map(|e| e.get_types(self, builder).unwrap())
+            .map(|e| e.get_types(self, builder).unwrap_or_default())
             .unwrap_or_default();
         let miss = binding
             .iter()

src/ast/pltype.rs

@@ -1716,7 +1716,7 @@ impl GenericType {
             };
             let ph = Arc::new(RefCell::new(PLType::Struct(place_holder)));
 
-            for it in impls.get_types(ctx, builder).unwrap() {
+            for it in impls.get_types(ctx, builder).unwrap_or_default() {
                 if let PLType::Trait(t) = &*it.clone().borrow() {
                     ctx.get_root_ctx().plmod.add_impl(
                         &ph.borrow().get_full_elm_name_without_generic(),

test/test/std_test.pi

@@ -24,4 +24,4 @@ pub fn test_std() void {
     arr1.slice(2, 1)[0] = 9;
     panic::assert(arr1.eq(&[1,3,9]));
     return;
-}
+}