Merge remote-tracking branch 'upstream/main'

Author: cryptonerdcn

listings/ch04-using-structs-to-structure-related-data/listing_04_03_mut_struct.cairo

@@ -23,7 +23,7 @@ fn build_user(email: felt252, username: felt252) -> User {
 
 // ANCHOR: build_user2
 fn build_user_short(email: felt252, username: felt252) -> User {
-    User { active: true, username: username, email: email, sign_in_count: 1,  }
+    User { active: true, username, email, sign_in_count: 1,  }
 }
 // ANCHOR_END: build_user2
 // ANCHOR_END: all

listings/ch07-generic-types-and-traits/no_listing_01_missing_tdrop.cairo

@@ -0,0 +1,28 @@
+// does_not_compile
+
+use array::ArrayTrait;
+
+// Specify generic type T between the angulars
+fn largest_list<T>(l1: Array<T>, l2: Array<T>) -> Array<T> {
+    if l1.len() > l2.len() {
+        l1
+    } else {
+        l2
+    }
+}
+
+fn main() {
+    let mut l1 = ArrayTrait::new();
+    let mut l2 = ArrayTrait::new();
+
+    l1.append(1);
+    l1.append(2);
+
+    l2.append(3);
+    l2.append(4);
+    l2.append(5);
+
+    // There is no need to specify the concrete type of T because
+    // it is inferred by the compiler
+    let l3 = largest_list(l1, l2);
+}

listings/ch07-generic-types-and-traits/no_listing_02_with_tdrop.cairo

@@ -0,0 +1,8 @@
+use array::ArrayTrait;
+fn largest_list<T, impl TDrop: Drop<T>>(l1: Array<T>, l2: Array<T>) -> Array<T> {
+    if l1.len() > l2.len() {
+        l1
+    } else {
+        l2
+    }
+}

listings/ch07-generic-types-and-traits/no_listing_03_missing_tcopy.cairo

@@ -0,0 +1,35 @@
+// does_not_compile
+use array::ArrayTrait;
+
+// Given a list of T get the smallest one.
+// The PartialOrd trait implements comparison operations for T
+fn smallest_element<T, impl TPartialOrd: PartialOrd<T>>(list: @Array<T>) -> T {
+    // This represents the smallest element through the iteration
+    // Notice that we use the desnap (*) operator
+    let mut smallest = *list[0];
+
+    // The index we will use to move through the list
+    let mut index = 1;
+
+    // Iterate through the whole list storing the smallest
+    loop {
+        if index >= list.len() {
+            break smallest;
+        }
+        if *list[index] < smallest {
+            smallest = *list[index];
+        }
+        index = index + 1;
+    }
+}
+
+fn main() {
+    let mut list: Array<u8> = ArrayTrait::new();
+    list.append(5);
+    list.append(3);
+    list.append(10);
+
+    // We need to specify that we are passing a snapshot of `list` as an argument
+    let s = smallest_element(@list);
+    assert(s == 3, 0);
+}

listings/ch07-generic-types-and-traits/no_listing_04_with_tcopy.cairo

@@ -0,0 +1,16 @@
+use array::ArrayTrait;
+fn smallest_element<T, impl TPartialOrd: PartialOrd<T>, impl TCopy: Copy<T>, impl TDrop: Drop<T>>(
+    list: @Array<T>
+) -> T {
+    let mut smallest = *list[0];
+    let mut index = 1;
+    loop {
+        if index >= list.len() {
+            break smallest;
+        }
+        if *list[index] < smallest {
+            smallest = *list[index];
+        }
+        index = index + 1;
+    }
+}

listings/ch07-generic-types-and-traits/no_listing_05_derive_generics.cairo

@@ -0,0 +1,9 @@
+#[derive(Drop)]
+struct Wallet<T> {
+    balance: T
+}
+
+
+fn main() {
+    let w = Wallet { balance: 3 };
+}

listings/ch07-generic-types-and-traits/no_listing_06_drop_explicit.cairo

@@ -0,0 +1,9 @@
+struct Wallet<T> {
+    balance: T
+}
+
+impl WalletDrop<T, impl TDrop: Drop<T>> of Drop<Wallet<T>>;
+
+fn main() {
+    let w = Wallet { balance: 3 };
+}

listings/ch07-generic-types-and-traits/no_listing_07_two_generics.cairo

@@ -0,0 +1,9 @@
+#[derive(Drop)]
+struct Wallet<T, U> {
+    balance: T,
+    address: U,
+}
+
+fn main() {
+    let w = Wallet { balance: 3, address: 14 };
+}

listings/ch07-generic-types-and-traits/no_listing_08_option.cairo

@@ -0,0 +1,4 @@
+enum Option<T> {
+    Some: T,
+    None: (),
+}

listings/ch07-generic-types-and-traits/no_listing_09_result.cairo

@@ -0,0 +1,4 @@
+enum Result<T, E> {
+    Ok: T,
+    Err: E,
+}