Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Use anonymous generic impl parameters #197

Merged
merged 1 commit into from
Oct 20, 2023
Merged

Use anonymous generic impl parameters #197

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
54 changes: 27 additions & 27 deletions src/ascii/src/integer.cairo
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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();
Expand Down Expand Up @@ -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() {
Expand All @@ -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();
Expand Down Expand Up @@ -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> {
Expand Down
6 changes: 2 additions & 4 deletions src/bytes/src/utils.cairo
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down Expand Up @@ -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 {
Expand Down
108 changes: 38 additions & 70 deletions src/data_structures/src/array_ext.cairo
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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) => {
Expand Down Expand Up @@ -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)
}

Expand All @@ -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 {
Expand Down Expand Up @@ -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 {
Expand Down Expand Up @@ -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() {
Expand All @@ -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() {
Expand All @@ -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; },
Expand All @@ -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() {
Expand All @@ -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; },
Expand All @@ -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() {
Expand All @@ -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![];
}
Expand All @@ -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() {
Expand Down
12 changes: 4 additions & 8 deletions src/data_structures/src/stack.cairo
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand Down Expand Up @@ -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();
Expand Down
Loading