From 196519767b42f9f7df1175a5c3f27f00750a7b41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Kami=C5=84ski?= <aundumla@gmail.com>
Date: Fri, 20 Oct 2023 15:27:42 +0200
Subject: [PATCH] Use anonymous generic impl parameters (#197)

<!--- Please provide a general summary of your changes in the title
above -->

## Pull Request type

<!-- Please try to limit your pull request to one type; submit multiple
pull requests if needed. -->

Please check the type of change your PR introduces:

- [ ] Bugfix
- [ ] Feature
- [ ] Code style update (formatting, renaming)
- [ ] Refactoring (no functional changes, no API changes)
- [ ] Build-related changes
- [ ] Documentation content changes
- [ ] Other (please describe):

## What is the current behavior?

<!-- Please describe the current behavior that you are modifying, or
link to a relevant issue. -->

Issue Number: N/A

## What is the new behavior?

<!-- Please describe the behavior or changes that are being added by
this PR. -->

-
-
-

## Does this introduce a breaking change?

- [ ] Yes
- [ ] No

<!-- If this does introduce a breaking change, please describe the
impact and migration path for existing applications below. -->

## Other information

<!-- Any other information that is important to this PR, such as
screenshots of how the component looks before and after the change. -->
---
 src/ascii/src/integer.cairo                   |  54 ++++-----
 src/bytes/src/utils.cairo                     |   6 +-
 src/data_structures/src/array_ext.cairo       | 108 ++++++------------
 src/data_structures/src/stack.cairo           |  12 +-
 .../src/tests/stack_test.cairo                |  22 ++--
 src/data_structures/src/tests/vec_test.cairo  |  68 +++--------
 src/data_structures/src/vec.cairo             |  12 +-
 src/encoding/src/reversible.cairo             |  27 ++---
 src/linalg/src/dot.cairo                      |   9 +-
 src/merkle_tree/src/merkle_tree.cairo         |   8 +-
 src/numeric/src/cumsum.cairo                  |   4 +-
 src/numeric/src/diff.cairo                    |   9 +-
 src/numeric/src/interpolate.cairo             |  18 +--
 src/numeric/src/trapezoidal_rule.cairo        |  24 ++--
 src/searching/src/binary_search.cairo         |   4 +-
 src/searching/src/dijkstra.cairo              |   5 +-
 src/sorting/src/bubble_sort.cairo             |   8 +-
 src/sorting/src/merge_sort.cairo              |  12 +-
 src/storage/src/list.cairo                    |   8 +-
 19 files changed, 146 insertions(+), 272 deletions(-)

diff --git a/src/ascii/src/integer.cairo b/src/ascii/src/integer.cairo
index 535be864..42c85760 100644
--- a/src/ascii/src/integer.cairo
+++ b/src/ascii/src/integer.cairo
@@ -18,14 +18,14 @@ trait ToAsciiArrayTrait<T> {
 // e.g. 123 -> [49, 50, 51]
 impl ToAsciiArrayTraitImpl<
     T,
-    impl TPartialOrd: PartialOrd<T>,
-    impl TDivRem: DivRem<T>,
-    impl TInto: Into<T, felt252>,
-    impl TryInto: TryInto<felt252, T>,
-    impl TTryIntoZero: TryInto<T, NonZero<T>>,
-    impl TZeroable: Zeroable<T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
+    +PartialOrd<T>,
+    +DivRem<T>,
+    +Into<T, felt252>,
+    +TryInto<felt252, T>,
+    +TryInto<T, NonZero<T>>,
+    +Zeroable<T>,
+    +Drop<T>,
+    +Copy<T>,
 > of ToAsciiArrayTrait<T> {
     fn to_ascii_array(self: T) -> Array<felt252> {
         let mut new_arr = self.to_inverse_ascii_array();
@@ -54,19 +54,19 @@ impl ToAsciiArrayTraitImpl<
     }
 }
 
-// generic implementation for small integers <u128 
+// generic implementation for small integers <u128
 // to transform its integers into a string represented as a single felt252
 // e.g. 1000 -> "1000"
 impl SmallIntegerToAsciiTraitImpl<
     T,
-    impl TPartialOrd: PartialOrd<T>,
-    impl TDivRem: DivRem<T>,
-    impl TInto: Into<T, felt252>,
-    impl TTryInto: TryInto<felt252, T>,
-    impl TTryIntoZero: TryInto<T, NonZero<T>>,
-    impl TZeroable: Zeroable<T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
+    +PartialOrd<T>,
+    +DivRem<T>,
+    +Into<T, felt252>,
+    +TryInto<felt252, T>,
+    +TryInto<T, NonZero<T>>,
+    +Zeroable<T>,
+    +Drop<T>,
+    +Copy<T>,
 > of ToAsciiTrait<T, felt252> {
     fn to_ascii(self: T) -> felt252 {
         if self <= 9.try_into().unwrap() {
@@ -86,19 +86,19 @@ impl SmallIntegerToAsciiTraitImpl<
     }
 }
 
-// generic implementation for big integers u128 
+// generic implementation for big integers u128
 // to transform its integers into a string represented as multiple felt252 if there is overflow
 // e.g. max_num + 123 -> ["max_num", "123"]
 impl BigIntegerToAsciiTraitImpl<
     T,
-    impl TPartialOrd: PartialOrd<T>,
-    impl TDivRem: DivRem<T>,
-    impl TInto: Into<T, felt252>,
-    impl TTryInto: TryInto<felt252, T>,
-    impl TTryIntoZero: TryInto<T, NonZero<T>>,
-    impl TZeroable: Zeroable<T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
+    +PartialOrd<T>,
+    +DivRem<T>,
+    +Into<T, felt252>,
+    +TryInto<felt252, T>,
+    +TryInto<T, NonZero<T>>,
+    +Zeroable<T>,
+    +Drop<T>,
+    +Copy<T>,
 > of ToAsciiTrait<T, Array<felt252>> {
     fn to_ascii(self: T) -> Array<felt252> {
         let mut data = ArrayTrait::new();
@@ -141,7 +141,7 @@ impl BigIntegerToAsciiTraitImpl<
 // -------------------------------------------------------------------------- //
 //                                  for u256                                  //
 // -------------------------------------------------------------------------- //
-// have to implement separately for u256 because 
+// have to implement separately for u256 because
 // it doesn't have the same implementations as the generic version
 impl U256ToAsciiArrayTraitImpl of ToAsciiArrayTrait<u256> {
     fn to_ascii_array(self: u256) -> Array<felt252> {
diff --git a/src/bytes/src/utils.cairo b/src/bytes/src/utils.cairo
index 54cdf1a6..e514288d 100644
--- a/src/bytes/src/utils.cairo
+++ b/src/bytes/src/utils.cairo
@@ -32,9 +32,7 @@ fn keccak_u128s_be(mut input: Span<u128>, n_bytes: usize) -> u256 {
 
 /// return the minimal value
 /// support u8, u16, u32, u64, u128, u256
-fn uint_min<T, impl TDrop: Drop<T>, impl TPartialOrd: PartialOrd<T>, impl TCopy: Copy<T>>(
-    l: T, r: T
-) -> T {
+fn uint_min<T, +Drop<T>, +PartialOrd<T>, +Copy<T>>(l: T, r: T) -> T {
     if l <= r {
         l
     } else {
@@ -219,7 +217,7 @@ fn read_sub_u128(value: u128, value_size: usize, offset: usize, size: usize) ->
 ///  - right_size: the size of right part in bytes
 /// Returns:
 ///  - value: the joined u128
-/// Examples: 
+/// Examples:
 /// u128_join(0x010203, 0xaabb, 2) -> 0x010203aabb
 /// u128_join(0x010203, 0, 2) -> 0x0102030000
 fn u128_join(left: u128, right: u128, right_size: usize) -> u128 {
diff --git a/src/data_structures/src/array_ext.cairo b/src/data_structures/src/array_ext.cairo
index 2fc6f898..5d535bb3 100644
--- a/src/data_structures/src/array_ext.cairo
+++ b/src/data_structures/src/array_ext.cairo
@@ -5,51 +5,35 @@ trait ArrayTraitExt<T> {
     fn append_all(ref self: Array<T>, ref arr: Array<T>);
     fn pop_front_n(ref self: Array<T>, n: usize);
     fn reverse(self: @Array<T>) -> Array<T>;
-    fn contains<impl TPartialEq: PartialEq<T>>(self: @Array<T>, item: T) -> bool;
+    fn contains<+PartialEq<T>>(self: @Array<T>, item: T) -> bool;
     fn concat(self: @Array<T>, a: @Array<T>) -> Array<T>;
-    fn index_of<impl TPartialEq: PartialEq<T>>(self: @Array<T>, item: T) -> Option<usize>;
-    fn occurrences_of<impl TPartialEq: PartialEq<T>>(self: @Array<T>, item: T) -> usize;
-    fn min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: @Array<T>
-    ) -> Option<T>;
-    fn index_of_min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: @Array<T>
-    ) -> Option<usize>;
-    fn max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: @Array<T>
-    ) -> Option<T>;
-    fn index_of_max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: @Array<T>
-    ) -> Option<usize>;
-    fn dedup<impl TPartialEq: PartialEq<T>>(self: @Array<T>) -> Array<T>;
-    fn unique<impl TPartialEq: PartialEq<T>>(self: @Array<T>) -> Array<T>;
+    fn index_of<+PartialEq<T>>(self: @Array<T>, item: T) -> Option<usize>;
+    fn occurrences_of<+PartialEq<T>>(self: @Array<T>, item: T) -> usize;
+    fn min<+PartialEq<T>, +PartialOrd<T>>(self: @Array<T>) -> Option<T>;
+    fn index_of_min<+PartialEq<T>, +PartialOrd<T>>(self: @Array<T>) -> Option<usize>;
+    fn max<+PartialEq<T>, +PartialOrd<T>>(self: @Array<T>) -> Option<T>;
+    fn index_of_max<+PartialEq<T>, +PartialOrd<T>>(self: @Array<T>) -> Option<usize>;
+    fn dedup<+PartialEq<T>>(self: @Array<T>) -> Array<T>;
+    fn unique<+PartialEq<T>>(self: @Array<T>) -> Array<T>;
 }
 
 trait SpanTraitExt<T> {
     fn pop_front_n(ref self: Span<T>, n: usize);
     fn pop_back_n(ref self: Span<T>, n: usize);
     fn reverse(self: Span<T>) -> Array<T>;
-    fn contains<impl TPartialEq: PartialEq<T>>(self: Span<T>, item: T) -> bool;
+    fn contains<+PartialEq<T>>(self: Span<T>, item: T) -> bool;
     fn concat(self: Span<T>, a: Span<T>) -> Span<T>;
-    fn index_of<impl TPartialEq: PartialEq<T>>(self: Span<T>, item: T) -> Option<usize>;
-    fn occurrences_of<impl TPartialEq: PartialEq<T>>(self: Span<T>, item: T) -> usize;
-    fn min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: Span<T>
-    ) -> Option<T>;
-    fn index_of_min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: Span<T>
-    ) -> Option<usize>;
-    fn max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: Span<T>
-    ) -> Option<T>;
-    fn index_of_max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: Span<T>
-    ) -> Option<usize>;
-    fn dedup<impl TPartialEq: PartialEq<T>>(self: Span<T>) -> Array<T>;
-    fn unique<impl TPartialEq: PartialEq<T>>(self: Span<T>) -> Array<T>;
+    fn index_of<+PartialEq<T>>(self: Span<T>, item: T) -> Option<usize>;
+    fn occurrences_of<+PartialEq<T>>(self: Span<T>, item: T) -> usize;
+    fn min<+PartialEq<T>, +PartialOrd<T>>(self: Span<T>) -> Option<T>;
+    fn index_of_min<+PartialEq<T>, +PartialOrd<T>>(self: Span<T>) -> Option<usize>;
+    fn max<+PartialEq<T>, +PartialOrd<T>>(self: Span<T>) -> Option<T>;
+    fn index_of_max<+PartialEq<T>, +PartialOrd<T>>(self: Span<T>) -> Option<usize>;
+    fn dedup<+PartialEq<T>>(self: Span<T>) -> Array<T>;
+    fn unique<+PartialEq<T>>(self: Span<T>) -> Array<T>;
 }
 
-impl ArrayImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of ArrayTraitExt<T> {
+impl ArrayImpl<T, +Copy<T>, +Drop<T>> of ArrayTraitExt<T> {
     fn append_all(ref self: Array<T>, ref arr: Array<T>) {
         match arr.pop_front() {
             Option::Some(v) => {
@@ -77,7 +61,7 @@ impl ArrayImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of ArrayTraitExt<T>
         self.span().reverse()
     }
 
-    fn contains<impl TPartialEq: PartialEq<T>>(self: @Array<T>, item: T) -> bool {
+    fn contains<+PartialEq<T>>(self: @Array<T>, item: T) -> bool {
         self.span().contains(item)
     }
 
@@ -104,48 +88,40 @@ impl ArrayImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of ArrayTraitExt<T>
         ret
     }
 
-    fn index_of<impl TPartialEq: PartialEq<T>>(self: @Array<T>, item: T) -> Option<usize> {
+    fn index_of<+PartialEq<T>>(self: @Array<T>, item: T) -> Option<usize> {
         self.span().index_of(item)
     }
 
-    fn occurrences_of<impl TPartialEq: PartialEq<T>>(self: @Array<T>, item: T) -> usize {
+    fn occurrences_of<+PartialEq<T>>(self: @Array<T>, item: T) -> usize {
         self.span().occurrences_of(item)
     }
 
-    fn min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: @Array<T>
-    ) -> Option<T> {
+    fn min<+PartialEq<T>, +PartialOrd<T>>(self: @Array<T>) -> Option<T> {
         self.span().min()
     }
 
-    fn index_of_min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: @Array<T>
-    ) -> Option<usize> {
+    fn index_of_min<+PartialEq<T>, +PartialOrd<T>>(self: @Array<T>) -> Option<usize> {
         self.span().index_of_min()
     }
 
-    fn max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        self: @Array<T>
-    ) -> Option<T> {
+    fn max<+PartialEq<T>, +PartialOrd<T>>(self: @Array<T>) -> Option<T> {
         self.span().max()
     }
 
-    fn index_of_max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        mut self: @Array<T>
-    ) -> Option<usize> {
+    fn index_of_max<+PartialEq<T>, +PartialOrd<T>>(mut self: @Array<T>) -> Option<usize> {
         self.span().index_of_max()
     }
 
-    fn dedup<impl TPartialEq: PartialEq<T>>(mut self: @Array<T>) -> Array<T> {
+    fn dedup<+PartialEq<T>>(mut self: @Array<T>) -> Array<T> {
         self.span().dedup()
     }
 
-    fn unique<impl TPartialEq: PartialEq<T>>(mut self: @Array<T>) -> Array<T> {
+    fn unique<+PartialEq<T>>(mut self: @Array<T>) -> Array<T> {
         self.span().unique()
     }
 }
 
-impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
+impl SpanImpl<T, +Copy<T>, +Drop<T>> of SpanTraitExt<T> {
     fn pop_front_n(ref self: Span<T>, mut n: usize) {
         loop {
             if n == 0 {
@@ -183,7 +159,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         response
     }
 
-    fn contains<impl TPartialEq: PartialEq<T>>(mut self: Span<T>, item: T) -> bool {
+    fn contains<+PartialEq<T>>(mut self: Span<T>, item: T) -> bool {
         loop {
             match self.pop_front() {
                 Option::Some(v) => { if *v == item {
@@ -216,7 +192,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         ret.span()
     }
 
-    fn index_of<impl TPartialEq: PartialEq<T>>(mut self: Span<T>, item: T) -> Option<usize> {
+    fn index_of<+PartialEq<T>>(mut self: Span<T>, item: T) -> Option<usize> {
         let mut index = 0_usize;
         loop {
             match self.pop_front() {
@@ -231,7 +207,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         }
     }
 
-    fn occurrences_of<impl TPartialEq: PartialEq<T>>(mut self: Span<T>, item: T) -> usize {
+    fn occurrences_of<+PartialEq<T>>(mut self: Span<T>, item: T) -> usize {
         let mut count = 0_usize;
         loop {
             match self.pop_front() {
@@ -243,9 +219,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         }
     }
 
-    fn min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        mut self: Span<T>
-    ) -> Option<T> {
+    fn min<+PartialEq<T>, +PartialOrd<T>>(mut self: Span<T>) -> Option<T> {
         let mut min = match self.pop_front() {
             Option::Some(item) => *item,
             Option::None => { return Option::None; },
@@ -260,9 +234,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         }
     }
 
-    fn index_of_min<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        mut self: Span<T>
-    ) -> Option<usize> {
+    fn index_of_min<+PartialEq<T>, +PartialOrd<T>>(mut self: Span<T>) -> Option<usize> {
         let mut index = 0;
         let mut index_of_min = 0;
         let mut min: T = match self.pop_front() {
@@ -281,9 +253,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         }
     }
 
-    fn max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        mut self: Span<T>
-    ) -> Option<T> {
+    fn max<+PartialEq<T>, +PartialOrd<T>>(mut self: Span<T>) -> Option<T> {
         let mut max = match self.pop_front() {
             Option::Some(item) => *item,
             Option::None => { return Option::None; },
@@ -298,9 +268,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         }
     }
 
-    fn index_of_max<impl TPartialEq: PartialEq<T>, impl TPartialOrd: PartialOrd<T>>(
-        mut self: Span<T>
-    ) -> Option<usize> {
+    fn index_of_max<+PartialEq<T>, +PartialOrd<T>>(mut self: Span<T>) -> Option<usize> {
         let mut index = 0;
         let mut index_of_max = 0;
         let mut max = match self.pop_front() {
@@ -319,7 +287,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         }
     }
 
-    fn dedup<impl TPartialEq: PartialEq<T>>(mut self: Span<T>) -> Array<T> {
+    fn dedup<+PartialEq<T>>(mut self: Span<T>) -> Array<T> {
         if self.len() == 0 {
             return array![];
         }
@@ -340,7 +308,7 @@ impl SpanImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>> of SpanTraitExt<T> {
         ret
     }
 
-    fn unique<impl TPartialEq: PartialEq<T>>(mut self: Span<T>) -> Array<T> {
+    fn unique<+PartialEq<T>>(mut self: Span<T>) -> Array<T> {
         let mut ret = array![];
         loop {
             match self.pop_front() {
diff --git a/src/data_structures/src/stack.cairo b/src/data_structures/src/stack.cairo
index efc6b940..0389112b 100644
--- a/src/data_structures/src/stack.cairo
+++ b/src/data_structures/src/stack.cairo
@@ -39,16 +39,14 @@ struct Felt252Stack<T> {
     len: usize,
 }
 
-impl DestructFeltStack<
-    T, impl TDrop: Drop<T>, impl TFelt252DictValue: Felt252DictValue<T>
-> of Destruct<Felt252Stack<T>> {
+impl DestructFeltStack<T, +Drop<T>, +Felt252DictValue<T>> of Destruct<Felt252Stack<T>> {
     fn destruct(self: Felt252Stack<T>) nopanic {
         self.elements.squash();
     }
 }
 
 impl Felt252StackImpl<
-    T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TFelt252DictValue: Felt252DictValue<T>,
+    T, +Copy<T>, +Drop<T>, +Felt252DictValue<T>,
 > of StackTrait<Felt252Stack<T>, T> {
     #[inline(always)]
     /// Creates a new Stack instance.
@@ -116,15 +114,13 @@ struct NullableStack<T> {
     len: usize,
 }
 
-impl DestructNullableStack<T, impl TDrop: Drop<T>> of Destruct<NullableStack<T>> {
+impl DestructNullableStack<T, +Drop<T>> of Destruct<NullableStack<T>> {
     fn destruct(self: NullableStack<T>) nopanic {
         self.elements.squash();
     }
 }
 
-impl NullableStackImpl<
-    T, impl TCopy: Copy<T>, impl TDrop: Drop<T>,
-> of StackTrait<NullableStack<T>, T> {
+impl NullableStackImpl<T, +Copy<T>, +Drop<T>,> of StackTrait<NullableStack<T>, T> {
     #[inline(always)]
     fn new() -> NullableStack<T> {
         let elements: Felt252Dict<Nullable<T>> = Default::default();
diff --git a/src/data_structures/src/tests/stack_test.cairo b/src/data_structures/src/tests/stack_test.cairo
index 6cdda8e6..980f4d0e 100644
--- a/src/data_structures/src/tests/stack_test.cairo
+++ b/src/data_structures/src/tests/stack_test.cairo
@@ -15,9 +15,7 @@ fn stack_is_empty_test<S, T, impl Stack: StackTrait<S, T>>(stack: @S) {
     assert(stack.is_empty(), 'stack should be empty');
 }
 
-fn stack_push_test<
-    S, T, impl Stack: StackTrait<S, T>, impl TDrop: Drop<T>, impl SDestruct: Destruct<S>
->(
+fn stack_push_test<S, T, impl Stack: StackTrait<S, T>, +Drop<T>, impl SDestruct: Destruct<S>>(
     ref stack: S, val_1: T, val_2: T
 ) {
     stack.push(val_1);
@@ -31,9 +29,9 @@ fn stack_peek_test<
     S,
     T,
     impl Stack: StackTrait<S, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
+    +Drop<T>,
+    +Copy<T>,
+    +PartialEq<T>,
     impl SDestruct: Destruct<S>
 >(
     ref stack: S, val_1: T, val_2: T
@@ -52,9 +50,9 @@ fn stack_pop_test<
     S,
     T,
     impl Stack: StackTrait<S, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
+    +Drop<T>,
+    +Copy<T>,
+    +PartialEq<T>,
     impl SDestruct: Destruct<S>
 >(
     ref stack: S, val_1: T, val_2: T
@@ -75,9 +73,9 @@ fn stack_push_pop_push_test<
     S,
     T,
     impl Stack: StackTrait<S, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
+    +Drop<T>,
+    +Copy<T>,
+    +PartialEq<T>,
     impl SDestruct: Destruct<S>
 >(
     ref stack: S, val_1: T, val_2: T, val_3: T
diff --git a/src/data_structures/src/tests/vec_test.cairo b/src/data_structures/src/tests/vec_test.cairo
index 57075948..bf571263 100644
--- a/src/data_structures/src/tests/vec_test.cairo
+++ b/src/data_structures/src/tests/vec_test.cairo
@@ -11,13 +11,7 @@ fn vec_new_test<V, T, impl Vec: VecTrait<V, T>>(vec: @V) {
 }
 
 fn vec_len_test<
-    V,
-    T,
-    impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
-    impl SDestruct: Destruct<V>
+    V, T, impl Vec: VecTrait<V, T>, +Drop<T>, +Copy<T>, +PartialEq<T>, impl SDestruct: Destruct<V>
 >(
     ref vec: V, val_1: T
 ) {
@@ -26,13 +20,7 @@ fn vec_len_test<
 }
 
 fn vec_get_test<
-    V,
-    T,
-    impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
-    impl SDestruct: Destruct<V>
+    V, T, impl Vec: VecTrait<V, T>, +Drop<T>, +Copy<T>, +PartialEq<T>, impl SDestruct: Destruct<V>
 >(
     ref vec: V, val_1: T
 ) {
@@ -42,13 +30,7 @@ fn vec_get_test<
 }
 
 fn vec_at_test<
-    V,
-    T,
-    impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
-    impl SDestruct: Destruct<V>
+    V, T, impl Vec: VecTrait<V, T>, +Drop<T>, +Copy<T>, +PartialEq<T>, impl SDestruct: Destruct<V>
 >(
     ref vec: V, val_1: T
 ) {
@@ -58,13 +40,7 @@ fn vec_at_test<
 }
 
 fn vec_at_out_of_bounds_test<
-    V,
-    T,
-    impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
-    impl SDestruct: Destruct<V>
+    V, T, impl Vec: VecTrait<V, T>, +Drop<T>, +Copy<T>, +PartialEq<T>, impl SDestruct: Destruct<V>
 >(
     ref vec: V
 ) {
@@ -72,13 +48,7 @@ fn vec_at_out_of_bounds_test<
 }
 
 fn vec_push_test<
-    V,
-    T,
-    impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
-    impl SDestruct: Destruct<V>
+    V, T, impl Vec: VecTrait<V, T>, +Drop<T>, +Copy<T>, +PartialEq<T>, impl SDestruct: Destruct<V>
 >(
     ref vec: V, val_1: T
 ) {
@@ -88,13 +58,7 @@ fn vec_push_test<
 }
 
 fn vec_set_test<
-    V,
-    T,
-    impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
-    impl SDestruct: Destruct<V>
+    V, T, impl Vec: VecTrait<V, T>, +Drop<T>, +Copy<T>, +PartialEq<T>, impl SDestruct: Destruct<V>
 >(
     ref vec: V, val_1: T, val_2: T
 ) {
@@ -105,13 +69,7 @@ fn vec_set_test<
 }
 
 fn vec_set_test_expect_error<
-    V,
-    T,
-    impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
-    impl SDestruct: Destruct<V>
+    V, T, impl Vec: VecTrait<V, T>, +Drop<T>, +Copy<T>, +PartialEq<T>, impl SDestruct: Destruct<V>
 >(
     ref vec: V, val_1: T, val_2: T
 ) {
@@ -123,9 +81,9 @@ fn vec_index_trait_test<
     V,
     T,
     impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
+    +Drop<T>,
+    +Copy<T>,
+    +PartialEq<T>,
     impl SDestruct: Destruct<V>,
     impl VIndex: Index<V, usize, T>
 >(
@@ -141,9 +99,9 @@ fn vec_index_trait_out_of_bounds_test<
     V,
     T,
     impl Vec: VecTrait<V, T>,
-    impl TDrop: Drop<T>,
-    impl TCopy: Copy<T>,
-    impl TPartialEq: PartialEq<T>,
+    +Drop<T>,
+    +Copy<T>,
+    +PartialEq<T>,
     impl SDestruct: Destruct<V>,
     impl VIndex: Index<V, usize, T>
 >(
diff --git a/src/data_structures/src/vec.cairo b/src/data_structures/src/vec.cairo
index 85a3c51c..1ad1dac7 100644
--- a/src/data_structures/src/vec.cairo
+++ b/src/data_structures/src/vec.cairo
@@ -74,18 +74,14 @@ struct Felt252Vec<T> {
     len: usize,
 }
 
-impl DestructFeltVec<
-    T, impl TDrop: Drop<T>, impl TFelt252DictValue: Felt252DictValue<T>
-> of Destruct<Felt252Vec<T>> {
+impl DestructFeltVec<T, +Drop<T>, +Felt252DictValue<T>> of Destruct<Felt252Vec<T>> {
     fn destruct(self: Felt252Vec<T>) nopanic {
         self.items.squash();
     }
 }
 
 
-impl Felt252VecImpl<
-    T, impl TDrop: Drop<T>, impl TCopy: Copy<T>, impl TFelt252DictValue: Felt252DictValue<T>
-> of VecTrait<Felt252Vec<T>, T> {
+impl Felt252VecImpl<T, +Drop<T>, +Copy<T>, +Felt252DictValue<T>> of VecTrait<Felt252Vec<T>, T> {
     fn new() -> Felt252Vec<T> {
         Felt252Vec { items: Default::default(), len: 0 }
     }
@@ -125,13 +121,13 @@ struct NullableVec<T> {
     len: usize,
 }
 
-impl DestructNullableVec<T, impl TDrop: Drop<T>> of Destruct<NullableVec<T>> {
+impl DestructNullableVec<T, +Drop<T>> of Destruct<NullableVec<T>> {
     fn destruct(self: NullableVec<T>) nopanic {
         self.items.squash();
     }
 }
 
-impl NullableVecImpl<T, impl TDrop: Drop<T>, impl TCopy: Copy<T>> of VecTrait<NullableVec<T>, T> {
+impl NullableVecImpl<T, +Drop<T>, +Copy<T>> of VecTrait<NullableVec<T>, T> {
     fn new() -> NullableVec<T> {
         NullableVec { items: Default::default(), len: 0 }
     }
diff --git a/src/encoding/src/reversible.cairo b/src/encoding/src/reversible.cairo
index 1858d7e5..f1fde240 100644
--- a/src/encoding/src/reversible.cairo
+++ b/src/encoding/src/reversible.cairo
@@ -25,31 +25,24 @@ trait ReversibleBits<T> {
 #[inline]
 fn reversing<
     T,
-    impl TCopy: Copy<T>,
-    impl TZeroable: Zeroable<T>,
-    impl TTryInto: TryInto<T, NonZero<T>>,
-    impl TDivRem: DivRem<T>,
-    impl TDrop: Drop<T>,
-    impl TMulEq: MulEq<T>,
-    impl TRem: Rem<T>,
-    impl TAddEq: AddEq<T>
+    +Copy<T>,
+    +Zeroable<T>,
+    +TryInto<T, NonZero<T>>,
+    +DivRem<T>,
+    +Drop<T>,
+    +MulEq<T>,
+    +Rem<T>,
+    +AddEq<T>
 >(
     word: T, size: usize, step: T
 ) -> (T, T) {
-    let result = TZeroable::zero();
+    let result = Zeroable::zero();
     reversing_partial_result(word, result, size, step)
 }
 
 #[inline]
 fn reversing_partial_result<
-    T,
-    impl TCopy: Copy<T>,
-    impl TDivRem: DivRem<T>,
-    impl TTryInto: TryInto<T, NonZero<T>>,
-    impl TDrop: Drop<T>,
-    impl TMulEq: MulEq<T>,
-    impl TRem: Rem<T>,
-    impl TAddEq: AddEq<T>
+    T, +Copy<T>, +DivRem<T>, +TryInto<T, NonZero<T>>, +Drop<T>, +MulEq<T>, +Rem<T>, +AddEq<T>
 >(
     mut word: T, mut onto: T, size: usize, step: T
 ) -> (T, T) {
diff --git a/src/linalg/src/dot.cairo b/src/linalg/src/dot.cairo
index ac201047..6ae5353b 100644
--- a/src/linalg/src/dot.cairo
+++ b/src/linalg/src/dot.cairo
@@ -8,14 +8,7 @@ use array::SpanTrait;
 /// * `ys` - The second sequence of len L.
 /// # Returns
 /// * `T` - The dot product.
-fn dot<
-    T,
-    impl TMul: Mul<T>,
-    impl TAddEq: AddEq<T>,
-    impl TZeroable: Zeroable<T>,
-    impl TCopy: Copy<T>,
-    impl TDrop: Drop<T>,
->(
+fn dot<T, +Mul<T>, +AddEq<T>, +Zeroable<T>, +Copy<T>, +Drop<T>,>(
     mut xs: Span<T>, mut ys: Span<T>
 ) -> T {
     // [Check] Inputs
diff --git a/src/merkle_tree/src/merkle_tree.cairo b/src/merkle_tree/src/merkle_tree.cairo
index e9f5f425..83fbd6cd 100644
--- a/src/merkle_tree/src/merkle_tree.cairo
+++ b/src/merkle_tree/src/merkle_tree.cairo
@@ -96,9 +96,7 @@ trait MerkleTreeTrait<T> {
 }
 
 /// MerkleTree Legacy implementation.
-impl MerkleTreeImpl<
-    T, impl THasher: HasherTrait<T>, impl TCopy: Copy<T>, impl TDrop: Drop<T>
-> of MerkleTreeTrait<T> {
+impl MerkleTreeImpl<T, +HasherTrait<T>, +Copy<T>, +Drop<T>> of MerkleTreeTrait<T> {
     /// Create a new merkle tree instance.
     fn new() -> MerkleTree<T> {
         MerkleTree { hasher: HasherTrait::new() }
@@ -181,7 +179,7 @@ impl MerkleTreeImpl<
 /// * `index` - The index of the given.
 /// * `hasher` - The hasher to use.
 /// * `proof` - The proof array to fill.
-fn compute_proof<T, impl THasher: HasherTrait<T>, impl TDrop: Drop<T>>(
+fn compute_proof<T, +HasherTrait<T>, +Drop<T>>(
     mut nodes: Array<felt252>, mut hasher: T, index: u32, ref proof: Array<felt252>
 ) {
     // Break if we have reached the top of the tree
@@ -222,7 +220,7 @@ fn compute_proof<T, impl THasher: HasherTrait<T>, impl TDrop: Drop<T>>(
 /// * `hasher` - The hasher to use.
 /// # Returns
 /// The next layer of nodes.
-fn get_next_level<T, impl THasher: HasherTrait<T>, impl TDrop: Drop<T>>(
+fn get_next_level<T, +HasherTrait<T>, +Drop<T>>(
     mut nodes: Span<felt252>, ref hasher: T
 ) -> Array<felt252> {
     let mut next_level: Array<felt252> = array![];
diff --git a/src/numeric/src/cumsum.cairo b/src/numeric/src/cumsum.cairo
index 38ddbc7c..ddb92a7a 100644
--- a/src/numeric/src/cumsum.cairo
+++ b/src/numeric/src/cumsum.cairo
@@ -7,9 +7,7 @@ use option::OptionTrait;
 /// * `sequence` - The sequence to operate.
 /// # Returns
 /// * `Array<T>` - The cumulative sum of sequence.
-fn cumsum<T, impl TAdd: Add<T>, impl TCopy: Copy<T>, impl TDrop: Drop<T>,>(
-    mut sequence: Span<T>
-) -> Array<T> {
+fn cumsum<T, +Add<T>, +Copy<T>, +Drop<T>,>(mut sequence: Span<T>) -> Array<T> {
     // [Check] Inputs
     assert(sequence.len() >= 1, 'Array must have at least 1 elt');
 
diff --git a/src/numeric/src/diff.cairo b/src/numeric/src/diff.cairo
index 61a62d99..76251801 100644
--- a/src/numeric/src/diff.cairo
+++ b/src/numeric/src/diff.cairo
@@ -8,14 +8,7 @@ use zeroable::Zeroable;
 /// * `sequence` - The sorted sequence to operate.
 /// # Returns
 /// * `Array<T>` - The discrete difference of sorted sequence.
-fn diff<
-    T,
-    impl TPartialOrd: PartialOrd<T>,
-    impl TSub: Sub<T>,
-    impl TCopy: Copy<T>,
-    impl TDrop: Drop<T>,
-    impl TZeroable: Zeroable<T>,
->(
+fn diff<T, +PartialOrd<T>, +Sub<T>, +Copy<T>, +Drop<T>, +Zeroable<T>,>(
     mut sequence: Span<T>
 ) -> Array<T> {
     // [Check] Inputs
diff --git a/src/numeric/src/interpolate.cairo b/src/numeric/src/interpolate.cairo
index 7ed45565..123346a0 100644
--- a/src/numeric/src/interpolate.cairo
+++ b/src/numeric/src/interpolate.cairo
@@ -28,15 +28,15 @@ enum Extrapolation {
 /// * `T` - The interpolated y at x.
 fn interpolate<
     T,
-    impl TPartialOrd: PartialOrd<T>,
-    impl TNumericLiteral: NumericLiteral<T>,
-    impl TAdd: Add<T>,
-    impl TSub: Sub<T>,
-    impl TMul: Mul<T>,
-    impl TDiv: Div<T>,
-    impl TZeroable: Zeroable<T>,
-    impl TCopy: Copy<T>,
-    impl TDrop: Drop<T>,
+    +PartialOrd<T>,
+    +NumericLiteral<T>,
+    +Add<T>,
+    +Sub<T>,
+    +Mul<T>,
+    +Div<T>,
+    +Zeroable<T>,
+    +Copy<T>,
+    +Drop<T>,
 >(
     x: T, xs: Span<T>, ys: Span<T>, interpolation: Interpolation, extrapolation: Extrapolation
 ) -> T {
diff --git a/src/numeric/src/trapezoidal_rule.cairo b/src/numeric/src/trapezoidal_rule.cairo
index ff2ab73f..33cdcbdb 100644
--- a/src/numeric/src/trapezoidal_rule.cairo
+++ b/src/numeric/src/trapezoidal_rule.cairo
@@ -11,17 +11,17 @@ use traits::Into;
 /// * `T` - The approximate integral.
 fn trapezoidal_rule<
     T,
-    impl TPartialOrd: PartialOrd<T>,
-    impl TNumericLiteral: NumericLiteral<T>,
-    impl TAdd: Add<T>,
-    impl TAddEq: AddEq<T>,
-    impl TSub: Sub<T>,
-    impl TMul: Mul<T>,
-    impl TDiv: Div<T>,
-    impl TCopy: Copy<T>,
-    impl TDrop: Drop<T>,
-    impl TZeroable: Zeroable<T>,
-    impl TInto: Into<u8, T>,
+    +PartialOrd<T>,
+    +NumericLiteral<T>,
+    +Add<T>,
+    +AddEq<T>,
+    +Sub<T>,
+    +Mul<T>,
+    +Div<T>,
+    +Copy<T>,
+    +Drop<T>,
+    +Zeroable<T>,
+    +Into<u8, T>,
 >(
     xs: Span<T>, ys: Span<T>
 ) -> T {
@@ -40,5 +40,5 @@ fn trapezoidal_rule<
         value += (*xs[index + 1] - *xs[index]) * (*ys[index] + *ys[index + 1]);
         index += 1;
     };
-    value / TInto::into(2)
+    value / Into::into(2_u8)
 }
diff --git a/src/searching/src/binary_search.cairo b/src/searching/src/binary_search.cairo
index 734e061c..3780e824 100644
--- a/src/searching/src/binary_search.cairo
+++ b/src/searching/src/binary_search.cairo
@@ -1,8 +1,6 @@
 use array::SpanTrait;
 
-fn binary_search<
-    T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TEq: PartialEq<T>, impl TOr: PartialOrd<T>
->(
+fn binary_search<T, +Copy<T>, +Drop<T>, +PartialEq<T>, +PartialOrd<T>>(
     span: Span<T>, val: T
 ) -> Option<u32> {
     // Initial check
diff --git a/src/searching/src/dijkstra.cairo b/src/searching/src/dijkstra.cairo
index ca5d2b7f..036f0a00 100644
--- a/src/searching/src/dijkstra.cairo
+++ b/src/searching/src/dijkstra.cairo
@@ -31,9 +31,7 @@ trait GraphTrait {
     fn shortest_path(ref self: Graph<Nullable<Span<Node>>>, source: u32) -> Felt252Dict<u128>;
 }
 
-impl DestructGraph<
-    T, impl TDrop: Drop<T>, impl TFelt252DictValue: Felt252DictValue<T>
-> of Destruct<Graph<T>> {
+impl DestructGraph<T, +Drop<T>, +Felt252DictValue<T>> of Destruct<Graph<T>> {
     fn destruct(self: Graph<T>) nopanic {
         self.adj_nodes.squash();
     }
@@ -192,4 +190,3 @@ fn is_node_visited(ref nodes: Array<u32>, current_node: u32) -> bool {
     };
     is_visited
 }
-
diff --git a/src/sorting/src/bubble_sort.cairo b/src/sorting/src/bubble_sort.cairo
index fa45a336..304c10dc 100644
--- a/src/sorting/src/bubble_sort.cairo
+++ b/src/sorting/src/bubble_sort.cairo
@@ -1,16 +1,12 @@
 //! Bubble sort algorithm
 use array::ArrayTrait;
 
-// Bubble sort 
+// Bubble sort
 /// # Arguments
 /// * `array` - Array to sort
 /// # Returns
 /// * `Array<usize>` - Sorted array
-fn bubble_sort_elements<
-    T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TPartialOrd: PartialOrd<T>
->(
-    mut array: Array<T>
-) -> Array<T> {
+fn bubble_sort_elements<T, +Copy<T>, +Drop<T>, +PartialOrd<T>>(mut array: Array<T>) -> Array<T> {
     if array.len() <= 1 {
         return array;
     }
diff --git a/src/sorting/src/merge_sort.cairo b/src/sorting/src/merge_sort.cairo
index 0b816a22..a86ebbbd 100644
--- a/src/sorting/src/merge_sort.cairo
+++ b/src/sorting/src/merge_sort.cairo
@@ -6,9 +6,7 @@ use array::ArrayTrait;
 /// * `arr` - Array to sort
 /// # Returns
 /// * `Array<T>` - Sorted array
-fn merge<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TPartialOrd: PartialOrd<T>>(
-    mut arr: Array<T>
-) -> Array<T> {
+fn merge<T, +Copy<T>, +Drop<T>, +PartialOrd<T>>(mut arr: Array<T>) -> Array<T> {
     let len = arr.len();
     if len <= 1 {
         return arr;
@@ -36,7 +34,7 @@ fn merge<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TPartialOrd: PartialO
 /// * `right_arr_ix` - Right array index
 /// # Returns
 /// * `Array<usize>` - Sorted array
-fn merge_recursive<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TPartialOrd: PartialOrd<T>>(
+fn merge_recursive<T, +Copy<T>, +Drop<T>, +PartialOrd<T>>(
     mut left_arr: Array<T>,
     mut right_arr: Array<T>,
     ref result_arr: Array<T>,
@@ -71,9 +69,7 @@ fn merge_recursive<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TPartialOrd
 /// * `index` - The index to split the array at.
 /// # Returns
 /// * `(Array<T>, Array<T>)` - The two arrays.
-fn split_array<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>>(
-    ref arr: Array<T>, index: usize
-) -> (Array<T>, Array<T>) {
+fn split_array<T, +Copy<T>, +Drop<T>>(ref arr: Array<T>, index: usize) -> (Array<T>, Array<T>) {
     let mut arr1 = array![];
     let mut arr2 = array![];
     let len = arr.len();
@@ -91,7 +87,7 @@ fn split_array<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>>(
 /// * `count` - The number of elements to fill.
 /// # Returns
 /// * `Array<T>` - The filled array.
-fn fill_array<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>>(
+fn fill_array<T, +Copy<T>, +Drop<T>>(
     ref arr: Array<T>, ref fill_arr: Array<T>, index: usize, count: usize
 ) {
     if count == 0 {
diff --git a/src/storage/src/list.cairo b/src/storage/src/list.cairo
index 1d7f40fc..84e2f356 100644
--- a/src/storage/src/list.cairo
+++ b/src/storage/src/list.cairo
@@ -32,7 +32,7 @@ trait ListTrait<T> {
     fn from_span(ref self: List<T>, span: Span<T>);
 }
 
-impl ListImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TStore: Store<T>> of ListTrait<T> {
+impl ListImpl<T, +Copy<T>, +Drop<T>, +Store<T>> of ListTrait<T> {
     fn len(self: @List<T>) -> u32 {
         *self.len
     }
@@ -130,9 +130,7 @@ impl ListImpl<T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TStore: Store<T>
     }
 }
 
-impl AListIndexViewImpl<
-    T, impl TCopy: Copy<T>, impl TDrop: Drop<T>, impl TStore: Store<T>
-> of IndexView<List<T>, u32, T> {
+impl AListIndexViewImpl<T, +Copy<T>, +Drop<T>, +Store<T>> of IndexView<List<T>, u32, T> {
     fn index(self: @List<T>, index: u32) -> T {
         self.get(index).expect('List index out of bounds')
     }
@@ -186,7 +184,7 @@ fn calculate_base_and_offset_for_index(
     (segment_base, offset.try_into().unwrap() * storage_size)
 }
 
-impl ListStore<T, impl TStore: Store<T>> of Store<List<T>> {
+impl ListStore<T, +Store<T>> of Store<List<T>> {
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<List<T>> {
         let len: u32 = Store::read(address_domain, base).unwrap_syscall();
         let storage_size: u8 = Store::<T>::size();