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

Remove Into<Id> and AsRef<str> #2704

Merged
merged 1 commit into from
Jan 11, 2024
Merged

Remove Into<Id> and AsRef<str> #2704

merged 1 commit into from
Jan 11, 2024

Conversation

GnomedDev
Copy link
Member

Into is often entirely unnecessary, and at worst hides the type of the Id with hard-coded Ids. This fixes this by just using the Id type itself, which also helps with monomorphisation bloat.

I also removed AsRef<str>, as this can just be &str without requiring a generic and without requiring a call to as_ref in the function, while also not accidentally taking ownership of a String passed in misleadingly.

@github-actions github-actions bot added model Related to the `model` module. client Related to the `client` module. builder Related to the `builder` module. cache Related to the `cache`-feature. http Related to the `http` module. utils Related to the `utils` module. examples Related to Serenity's examples. labels Jan 9, 2024
@GnomedDev GnomedDev force-pushed the no-into-id-or-asref-str branch from 8feec80 to b165f32 Compare January 10, 2024 21:42
@arqunis arqunis added enhancement An improvement to Serenity. breaking change The public API is changed, resulting in miscompilations or unexpected new behaviour for users labels Jan 10, 2024
@GnomedDev GnomedDev force-pushed the no-into-id-or-asref-str branch from b165f32 to 23aeb34 Compare January 10, 2024 23:52
@arqunis arqunis merged commit 4df87e1 into serenity-rs:next Jan 11, 2024
22 checks passed
@GnomedDev GnomedDev deleted the no-into-id-or-asref-str branch January 11, 2024 00:28
arqunis pushed a commit to arqunis/serenity that referenced this pull request Jan 16, 2024
@GnomedDev @arqunis
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
899d363 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
arqunis pushed a commit to arqunis/serenity that referenced this pull request Jan 22, 2024
@GnomedDev @arqunis
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
6571ed4 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Feb 9, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
9b738ba 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
arqunis pushed a commit that referenced this pull request Mar 1, 2024
@GnomedDev @arqunis
Remove Into<*Id> and AsRef<str> (#2704)
5d19101 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 10, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
83249f3 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 11, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
130749a 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 11, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
25cabee 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Mar 13, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
94493b1 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 13, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
cff4587 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Mar 19, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
8280247 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Mar 19, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
17aaf89 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 21, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
f1b1ff2 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 25, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
88d6cd9 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 29, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
a54fb6f 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Mar 31, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
67b9280 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Mar 31, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
5230089 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Apr 1, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
bb4509b 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request May 14, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
9ac990f 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request May 14, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
696e00a 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request May 23, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
f600397 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request May 28, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
37b8daf 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Jun 9, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
a60d9f9 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Jun 22, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
e94edcc 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Jun 22, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
d74b29d 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
mkrasnitski pushed a commit to mkrasnitski/serenity that referenced this pull request Jul 29, 2024
@GnomedDev @mkrasnitski
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
6a8edb3 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
mkrasnitski pushed a commit to mkrasnitski/serenity that referenced this pull request Jul 30, 2024
@GnomedDev @mkrasnitski
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
d7e5e53 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Aug 16, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
2dd7697 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Oct 7, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
e5846bc 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Oct 20, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
79c0e7c 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Oct 20, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
62d3335 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Nov 11, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
188b539 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit that referenced this pull request Nov 13, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (#2704)
7b0de9f 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
GnomedDev added a commit to GnomedDev/serenity that referenced this pull request Nov 15, 2024
@GnomedDev
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
5bf83c9 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
mkrasnitski pushed a commit to mkrasnitski/serenity that referenced this pull request Dec 8, 2024
@GnomedDev @mkrasnitski
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
784069b 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
arqunis pushed a commit to arqunis/serenity that referenced this pull request Jan 16, 2025
@GnomedDev @arqunis
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
145331c 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
mkrasnitski pushed a commit to mkrasnitski/serenity that referenced this pull request Feb 1, 2025
@GnomedDev @mkrasnitski
Remove Into<*Id> and AsRef<str> (serenity-rs#2704)
2902221 
`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers

@arqunis arqunis arqunis approved these changes

Assignees
No one assigned
Labels
breaking change The public API is changed, resulting in miscompilations or unexpected new behaviour for users builder Related to the `builder` module. cache Related to the `cache`-feature. client Related to the `client` module. enhancement An improvement to Serenity. examples Related to Serenity's examples. http Related to the `http` module. model Related to the `model` module. utils Related to the `utils` module.
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
2 participants
@GnomedDev @arqunis