Address maintainer feedback

config.json

@@ -20,8 +20,7 @@
   },
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/%{snake_slug}.cairo"
@@ -84,7 +83,7 @@
       },
       {
         "slug": "lucians-luscious-lasagna",
-        "name": "Lucians Luscious Lasagna",
+        "name": "Lucian's Luscious Lasagna",
         "uuid": "8302f8de-14d7-45dd-9a65-812bc1ed5464",
         "practices": [
           "functions"

exercises/concept/low-power-embedded-game/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/low_power_embedded_game.cairo"

exercises/concept/low-power-embedded-game/src/lib.cairo

@@ -1,14 +1,14 @@
 #[generate_trait]
 pub impl DivmodImpl of DivmodTrait {
     fn divmod(self: @u16, divisor: u16) -> (u16, u16) {
-        panic!("implement `fn divmod`")
+        panic!("implement `divmod`")
     }
 }
 
 #[generate_trait]
 pub impl EvensImpl<T, +Drop<T>, +Copy<T>> of EvensTrait<T> {
     fn evens(self: @Array<T>) -> Array<T> {
-        panic!("implement `fn evens`")
+        panic!("implement `evens`")
     }
 }
 
@@ -17,6 +17,6 @@ pub type Position = (i16, i16);
 #[generate_trait]
 pub impl PositionImpl of PositionTrait {
     fn manhattan(self: @Position) -> i16 {
-        panic!("implement `fn manhattan`")
+        panic!("implement `manhattan`")
     }
 }

exercises/practice/allergies/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/allergies.cairo"

exercises/practice/allergies/src/lib.cairo

@@ -16,16 +16,17 @@ pub enum Allergen {
 #[generate_trait]
 pub impl AllergiesImpl of AllergiesTrait {
     fn new(score: u32) -> Allergies {
-        panic!("Given the '{score}' score, construct a new Allergies struct.")
+        // construct a new Allergies struct
+        panic!("implement `new`")
     }
 
     fn is_allergic_to(self: @Allergies, allergen: @Allergen) -> bool {
-        panic!("Determine if the patient is allergic to the '{allergen:?}' allergen.")
+        // determine whether the person is allergic to '{allergen}'
+        panic!("implement `is_allergic_to`")
     }
 
     fn allergies(self: @Allergies) -> Array<Allergen> {
-        panic!(
-            "Return the list of allergens contained within the score with which the Allergies struct was made."
-        )
+        // return a list of allergies based on the person's allergy score
+        panic!("implement `allergies`")
     }
 }

exercises/practice/anagram/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/anagram.cairo"

exercises/practice/anagram/.meta/example.cairo

@@ -41,14 +41,14 @@ impl SetEq of PartialEq<Set> {
     }
 }
 
-pub fn anagrams_for(word: @ByteArray, inputs: @Set) -> Set {
+pub fn anagrams_for(word: @ByteArray, candidates: @Set) -> Set {
     let mut word_sorted = @sort_ignore_case(word);
     let mut anagrams = Set { values: array![] };
-    let mut i = inputs.values.len();
+    let mut i = candidates.values.len();
 
     while i != 0 {
         i -= 1;
-        let candidate = inputs.values[i];
+        let candidate = candidates.values[i];
 
         let is_anagram = word.len() == candidate.len()
             && IgnoreCase::ne(word, candidate)

exercises/practice/anagram/src/lib.cairo

@@ -4,20 +4,24 @@ struct Set {}
 #[generate_trait]
 pub impl SetImpl of SetTrait {
     fn new(values: Array<ByteArray>) -> Set {
-        panic!()
+        // construct a new Set struct
+        panic!("implement `new`")
     }
 }
 
 impl SetEq of PartialEq<Set> {
     fn eq(lhs: @Set, rhs: @Set) -> bool {
-        panic!()
+        // determine whether the two Sets are equal
+        panic!("implement `eq`")
     }
 
     fn ne(lhs: @Set, rhs: @Set) -> bool {
-        panic!()
+        // determine whether the two Sets are NOT equal
+        panic!("implement `ne`")
     }
 }
 
-pub fn anagrams_for(word: @ByteArray, inputs: @Set) -> Set {
-    panic!()
+pub fn anagrams_for(word: @ByteArray, candidates: @Set) -> Set {
+    // construct a Set of words from the set of candidates that are anagrams of {word}
+    panic!("implement `anagrams_for`")
 }

exercises/practice/armstrong-numbers/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/armstrong_numbers.cairo"

exercises/practice/armstrong-numbers/src/lib.cairo

@@ -1,3 +1,3 @@
 pub fn is_armstrong_number(num: u128) -> bool {
-    panic!("true if {num} is an armstrong number")
+    panic!("implement `is_armstrong_number`")
 }

exercises/practice/beer-song/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/beer_song.cairo"

exercises/practice/beer-song/src/lib.cairo

@@ -1,11 +1,14 @@
 pub fn verse(n: u32) -> ByteArray {
-    panic!("emit verse {n}")
+    // return verse {n}
+    panic!("implement `verse`")
 }
 
 pub fn verses(start: u32, take_count: u32) -> ByteArray {
-    panic!("sing {take_count} verses from {start}")
+    // return {take_count} verses from {start}
+    panic!("implement `verses`")
 }
 
 pub fn song() -> ByteArray {
-    panic!("sing the whole song")
+    // return the whole song
+    panic!("implement `song`")
 }

exercises/practice/binary-search/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/binary_search.cairo"

exercises/practice/binary-search/src/lib.cairo

@@ -1,5 +1,5 @@
 pub fn find(search_array: @Array<usize>, value: usize) -> Option<usize> {
-    panic!(
-        "Using the binary search algorithm, find the element '{value}' in the array '{search_array:?}' and return its index."
-    )
+    // use the binary search algorithm to find the element '{value}' in the array '{search_array:?}'
+    // and return its index, otherwise return Option::None 
+    panic!("implement `find`")
 }

exercises/practice/clock/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/clock.cairo"

exercises/practice/clock/src/lib.cairo

@@ -7,17 +7,20 @@ struct Clock {
 
 impl ClockDisplay of Display<Clock> {
     fn fmt(self: @Clock, ref f: Formatter) -> Result<(), Error> {
-        panic!("implement `fmt` to define how the Clock should be displayed as a string")
+        // define how the Clock should be converted to a string
+        panic!("implement `fmt`")
     }
 }
 
 #[generate_trait]
 pub impl ClockImpl of ClockTrait {
     fn new(hour: i32, minute: i32) -> Clock {
+        // construct a new Clock struct
         panic!("implement `new`")
     }
 
     fn add_minutes(ref self: Clock, minutes: i32) -> Clock {
+        // adds {minutes} to the current Clock and returns the result as a new Clock
         panic!("implement `add_minutes`")
     }
 

exercises/practice/custom-set/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/custom_set.cairo"

exercises/practice/custom-set/.meta/example.cairo

@@ -122,36 +122,36 @@ pub impl CustomSetImpl<
     }
 
     #[must_use]
-    fn union(self: @CustomSet<T>, other: @CustomSet<T>) -> CustomSet<T> {
+    fn difference(self: @CustomSet<T>, other: @CustomSet<T>) -> CustomSet<T> {
         let mut collection: Array<T> = array![];
         let mut i = 0;
         while let Option::Some(value) = self
             .collection
             .get(i) {
-                collection.append(*value.unbox());
-                i += 1;
-            };
-        let mut i = 0;
-        while let Option::Some(value) = other
-            .collection
-            .get(i) {
-                collection.append(*value.unbox());
+                let unboxed = value.unbox();
+                if !other.contains(unboxed) {
+                    collection.append(*unboxed);
+                }
                 i += 1;
             };
         CustomSetImpl::<T>::new(@collection)
     }
 
     #[must_use]
-    fn difference(self: @CustomSet<T>, other: @CustomSet<T>) -> CustomSet<T> {
+    fn union(self: @CustomSet<T>, other: @CustomSet<T>) -> CustomSet<T> {
         let mut collection: Array<T> = array![];
         let mut i = 0;
         while let Option::Some(value) = self
             .collection
             .get(i) {
-                let unboxed = value.unbox();
-                if !other.contains(unboxed) {
-                    collection.append(*unboxed);
-                }
+                collection.append(*value.unbox());
+                i += 1;
+            };
+        let mut i = 0;
+        while let Option::Some(value) = other
+            .collection
+            .get(i) {
+                collection.append(*value.unbox());
                 i += 1;
             };
         CustomSetImpl::<T>::new(@collection)

exercises/practice/custom-set/src/lib.cairo

@@ -5,11 +5,13 @@ impl CustomSetEq<
     T, +Copy<T>, +Drop<T>, +PartialEq<T>, +core::fmt::Display<T>
 > of PartialEq<CustomSet<T>> {
     fn eq(lhs: @CustomSet<T>, rhs: @CustomSet<T>) -> bool {
-        panic!()
+        // determine whether the two CustomSets are equal
+        panic!("implement `eq`")
     }
 
     fn ne(lhs: @CustomSet<T>, rhs: @CustomSet<T>) -> bool {
-        panic!()
+        // determine whether the two CustomSets are NOT equal
+        panic!("implement `ne`")
     }
 }
 
@@ -18,41 +20,52 @@ pub impl CustomSetImpl<
     T, +Copy<T>, +Drop<T>, +core::fmt::Display<T>, +PartialEq<T>
 > of CustomSetTrait<T> {
     fn new(input: @Array<T>) -> CustomSet<T> {
-        panic!()
+        // construct a new CustomSet struct
+        panic!("implement `new`")
     }
 
     fn add(ref self: CustomSet<T>, element: T) {
-        panic!();
+        // add {element} to the CustomSet
+        panic!("implement `add`")
     }
 
     fn contains(self: @CustomSet<T>, element: @T) -> bool {
-        panic!()
+        // determine whether the CustomSet contains {element}
+        panic!("implement `contains`")
     }
 
     fn is_subset(self: @CustomSet<T>, other: @CustomSet<T>) -> bool {
-        panic!()
+        // determine whether {self} is a subset of {other}
+        panic!("implement `is_subset`")
     }
 
     fn is_empty(self: @CustomSet<T>) -> bool {
-        panic!()
+        // determine whether {self} is empty
+        panic!("implement `is_empty`")
     }
 
     fn is_disjoint(self: @CustomSet<T>, other: @CustomSet<T>) -> bool {
-        panic!()
+        // determine whether {self} and {other} have no elements in common
+        panic!("implement `is_disjoint`")
     }
 
     #[must_use]
     fn intersection(self: @CustomSet<T>, other: @CustomSet<T>) -> CustomSet<T> {
-        panic!()
+        // construct a CustomSet that contains only those elements from {self} that
+        // are also contained in {other}
+        panic!("implement `intersection`")
     }
 
     #[must_use]
     fn difference(self: @CustomSet<T>, other: @CustomSet<T>) -> CustomSet<T> {
-        panic!()
+        // construct a CustomSet that contains only those elements from {self} that
+        // are NOT contained in {other}
+        panic!("implement `difference`")
     }
 
     #[must_use]
     fn union(self: @CustomSet<T>, other: @CustomSet<T>) -> CustomSet<T> {
-        panic!()
+        // construct a CustomSet that contains all of the elements from both {self} AND {other}
+        panic!("implement `union`")
     }
 }

exercises/practice/dominoes/.meta/config.json

@@ -4,8 +4,7 @@
   ],
   "files": {
     "solution": [
-      "src/lib.cairo",
-      "Scarb.toml"
+      "src/lib.cairo"
     ],
     "test": [
       "tests/dominoes.cairo"

exercises/practice/dominoes/src/lib.cairo

@@ -1,7 +1,6 @@
 pub type Domino = (u8, u8);
 
 pub fn chain(dominoes: @Array<Domino>) -> Option<Array<Domino>> {
-    panic!(
-        "From the given dominoes '{dominoes:?}' construct a proper dominoes chain or return Option::None if it is not possible."
-    )
+    // from the given dominoes '{dominoes:?}' construct a proper dominoes chain or return Option::None if it is not possible
+    panic!("implement `chain`")
 }