如何在使此函数泛型时满足特征界限？
在使函数泛型时满足特征界限，可以通过使用特征（traits）来实现。特征是一种定义函数功能的方式，它可以用于指定函数参数的类型或函数返回值的类型。通过使用特征，可以在函数定义中指定泛型参数，并限制这些参数必须满足特定的特征。
要使函数泛型时满足特征界限，可以按照以下步骤进行操作：
- 定义特征：首先，需要定义一个特征来描述所需的特征界限。特征可以包含函数签名、常量、类型别名等。例如，可以定义一个特征
MyTrait，其中包含一个函数my_function和一个常量MY_CONSTANT。
trait MyTrait {
fn my_function(&self);
const MY_CONSTANT: i32;
}- 实现特征：接下来，需要为满足特征界限的类型实现特征。在实现特征时，需要提供特征中定义的函数的具体实现。例如，可以为类型
MyType实现特征MyTrait。
struct MyType;
impl MyTrait for MyType {
fn my_function(&self) {
println!("Hello, world!");
}
const MY_CONSTANT: i32 = 42;
}- 使用泛型参数并满足特征界限：在函数定义中，可以使用泛型参数，并通过特征界限来限制泛型参数必须满足特定的特征。例如，可以定义一个函数
my_generic_function，其中的泛型参数T必须满足特征MyTrait。
fn my_generic_function<T: MyTrait>(param: T) {
param.my_function();
println!("Constant: {}", T::MY_CONSTANT);
}通过以上步骤，就可以在使函数泛型时满足特征界限。在调用my_generic_function时，可以传递任何满足特征MyTrait的类型作为参数。
示例代码中使用的是Rust编程语言作为示例，但这个概念在其他编程语言中也是类似的。对于其他编程语言，可以根据其语法和特性来实现类似的功能。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数计算（Serverless Cloud Function）：腾讯云提供的无服务器计算服务，可帮助开发者更轻松地构建和运行事件驱动型的应用程序。
- 腾讯云云服务器（CVM）：腾讯云提供的弹性云服务器，可提供可靠的计算能力支持，适用于各种应用场景。
- 腾讯云数据库（TencentDB）：腾讯云提供的全球分布式的云数据库服务，支持多种数据库引擎，适用于各种规模的应用程序。
- 腾讯云安全产品：腾讯云提供的多种安全产品和解决方案，包括云安全中心、DDoS防护、Web应用防火墙等，可帮助保护云计算环境的安全。
- 腾讯云人工智能（AI）：腾讯云提供的人工智能服务和解决方案，包括图像识别、语音识别、自然语言处理等，可应用于各种领域。
- 腾讯云物联网（IoT）：腾讯云提供的物联网开发平台，可帮助开发者快速构建和管理物联网设备和应用。
- 腾讯云移动开发：腾讯云提供的移动应用开发服务，包括移动应用测试、移动应用分发等，可帮助开发者提高移动应用的开发效率和质量。
- 腾讯云对象存储（COS）：腾讯云提供的高可靠、低成本的对象存储服务，适用于存储和处理各种类型的数据。
- 腾讯云区块链（Blockchain）：腾讯云提供的区块链服务，可帮助开发者构建和管理区块链网络和应用。
- 腾讯云元宇宙（Metaverse）：腾讯云提供的元宇宙解决方案，可帮助开发者构建虚拟现实和增强现实应用。
相关·内容
1回答
我读了的源代码，发现了
pub fn put<T>(uri: T) -> Builder
where
Uri: TryFrom<T>,
<Uri as TryFrom<T>>::Error: Into<crate::Error>,
{
Builder::new().method(Method::PUT).uri(uri)
}
在这个片段中，Uri是类型，T是泛型元素。我一直都看到建筑where T: SomeTrait，但没有看到SomeType: SomeTrait<T>。这个建筑
浏览 2提问于2020-05-02得票数 0
回答已采纳
如何将计算结果与泛型进行比较？T总是一些无符号整数类型(u64、u32等)，所以代码片段中的应该可以工作，但是我如何才能说服rust编译器呢？ fn reproduction<T>(val: T) -> bool
where
T: PartialOrd
{
let var_of_type_integer = 7; // actually the result of a calculation
if val < var_of_type_integer { // ERROR: expected type parameter, found integ
浏览 22提问于2019-12-31得票数 1
回答已采纳
1回答
我试图使几个通用函数工作在数字上，但我正在与函数签名斗争。
也许我是从错误的角度来解决这个问题，但到目前为止，我是这样做的。我不想这样做；所以，如果我是从错误的角度来解决这个问题(创建一个简单的通用数学函数库)，那么一定要对我进行教育。
假设我想要一个函数，add，它将两个数字相加：
use std::ops::Add;
fn add(a: Add, b: Add) -> Add::Output {
a + b
}
这不能编译。不过，这里有一个游乐场：
我基本上有两个错误。第一项：
error[E0393]: the type parameter `RHS` must be e
浏览 0提问于2018-11-06得票数 0
回答已采纳
2回答
我在试着理解“锈蚀”中的仿制药。我不知道这里出了什么问题
fn say<T>(msg: &T) {
let slen = msg.chars().count();
if slen > 0 {
println!("Char Count {} " ,slen);
}
}
fn main() {
let msg = String::from("Hello World from Rust!!!");
say::<String>(&msg);
}
编译错误：
er
浏览 2提问于2021-03-25得票数 1
回答已采纳
我有一个函数，它使用diesel根据给定的ID从DB中获取对象： fn get_db_site(pool: web::Data<Pool>, site_id: u32) -> Result<Site, diesel::result::Error> {
let conn = pool.get().unwrap();
dsl::site.find(site_id).get_result::<Site>(&conn)
浏览 12提问于2020-09-15得票数 0
3回答
我有这个特点和简单的结构：
use std::path::{Path, PathBuf};
trait Foo {
type Item: AsRef<Path>;
type Iter: Iterator<Item = Self::Item>;
fn get(&self) -> Self::Iter;
}
struct Bar {
v: Vec<PathBuf>,
}
我想为Bar实现Foo特征
impl Foo for Bar {
type Item = PathBuf;
type Iter
浏览 2提问于2015-11-16得票数 48
回答已采纳
下面的代码片段来自衬底。
是干什么的呢？如何为泛型类型的Hash实现特性T？注释掉impl <...>和编译器会抱怨“特性Hash不是为Vec<u8>实现的”，但是该空代码段(impl<...>)是如何实现Hash for Vec<u8>的。
pub trait Hash:
Send
+ Sync
+ Sized
+ Eq
+ PartialEq
+ Clone
+ Default
+ fmt::Debug
+ Codec
+ std::hash::Hash
浏览 11提问于2022-07-24得票数 1
我有以下几点
trait T {}
type Iter = fn() -> Iterator<Item = T>;
fn func(iter: Iter) {
for a in iter() {
// ...
}
}
我希望iter返回一个带有move语义的迭代器，所以我不应该返回&Iterator。问题是，Iterator是一种特征，所以它没有大小。上面的代码得到一个编译错误，指出Iterable不满足sized特征，因为所有局部变量都必须静态调整大小。
最重要的是，T也是一个特征，因此没有大小，所以我也不能将a绑定到它，因为它没有
浏览 2提问于2016-08-26得票数 2
2回答
我可以定义一个struct类型，它使用具有特征绑定的泛型类型参数：
struct MyStruct<T: Clone> {
field: T,
}
这使我无法用不符合特征绑定的泛型类型实例化MyStruct：
// Note: does not implement Clone
struct UnitStruct;
fn main() {
// ERROR: Unsatisfied trait bound: UnitStruct: Clone
let s = MyStruct { field: UnitStruct };
}
但是我为什么要这样定义我的结构呢
浏览 11提问于2022-11-16得票数 3
我正在尝试用下面的代码编写一个泛型函数来编码和解码prost消息。 pub fn write_message(&mut self, message: &mut dyn prost::Message) -> std::io::Result<usize> {
let mut buf: Vec<u8> = Vec::new();
buf.reserve(message.encoded_len());
message.encode(&mut buf).unwrap();
self.stream.write(&
浏览 5提问于2021-07-01得票数 0
回答已采纳
我希望在Rust中构建一个类，它允许在实例化方面提供多样性和便利性，类似于可以向std::net::TcpStream的connect方法提供多个输入的方式。
我有以下的测试，但很少知道我需要构建的结构或特征来达到这个结果。
#[cfg(test)]
mod test {
use super::Ipv4Network;
use std::net::Ipv4Addr;
#[test]
fn instantiation() {
let net_addr = Ipv4Addr::new(10, 0, 0, 0);
let net_ma
浏览 4提问于2015-10-17得票数 1
回答已采纳
1回答
我正在尝试将异步函数封装在结构中。例如：
use std::future::Future;
struct X;
struct Y;
async fn f(x: &X) -> Y {
Y
}
struct MyStruct<F, Fut>(F)
where
F: Fn(&X) -> Fut,
Fut: Future<Output = Y>;
fn main() {
MyStruct(f);
}
编译器对此有以下错误(无益)：
error[E0308]: mismatched types
-->
浏览 4提问于2021-06-15得票数 4
回答已采纳
标题可能令人费解，但我不知道如何很好地表达这个想法。我会澄清我的意思。是否可以根据传递给它的变量传递一个不同的函数。让我给你举个例子
trait Lift<A, B> {
type Source;
type Target1;
}
impl<A, B> Lift<A, B> for Option<A> {
type Source = Self;
type Target1 = Option<B>;
}
trait Functor<A, B>: Lift<A, B> {
fn
浏览 2提问于2022-11-14得票数 0
我使用的是在外部机箱中定义的，如下所示：
pub trait I2CDevice {
type Error: Error;
// members
}
它及其任何成员都不包含任何通用参数。
我正在为任何委托给内部/具体I2CDevice的I2CDevice实现创建一个装饰器，为诊断目的添加控制台打印：
struct debugDeviceDecorator<'a, T: I2CDevice<Error = LinuxI2CError> + Sized + 'a> {
device: &'a mut T,
}
imp
浏览 0提问于2017-03-11得票数 1
1回答
我希望实现一个允许分配泛型类型的特性。到目前为止，我已经对u32和String类型进行了测试：
trait Test {
fn test(&self, input: &str) -> Self;
}
impl Test for String {
fn test(&self, input: &str) -> Self {
input.parse().unwrap()
}
}
impl Test for u32 {
fn test(&self, input: &str) -> Se
浏览 1提问于2021-01-29得票数 1
回答已采纳
1回答
我尝试使用impl来处理一些奇怪的类型逻辑。以下是该bug的快速重建：
trait Schrodingers {}
struct AliveCat;
impl Schrodingers for Container<AliveCat> {}
struct DeadCat;
impl Schrodingers for Container<DeadCat> {}
struct Container<Cat1>
where Container<Cat1>: Schrodingers
{
cat: Cat1,
}
impl<Cat
浏览 3提问于2017-01-08得票数 4
我希望在Struct自定义运行库中使用创建数据类型。数据类型是泛型的，因此我可以在不同的类型上使用它。
我正在尝试以下内容，但它没有编译。编译器抱怨没有为T找到子类型。
pub struct CustomDataType<T> {
data: Vec<u8>,
balance: T::Balance,
owner: T::AccountId,
}
我应该能够编译一个通用结构。
浏览 0提问于2019-01-11得票数 3
回答已采纳
满足MyTrait的类型应该传递给由deserialize_with指定的deserialize_data。这是我的
use serde::{Deserialize, Deserializer}; // 1.0.117
use serde_json; // 1.0.59
type Item = Result<String, Box<dyn std::error::Error + Send + Sync>>;
pub trait MyTrait {
fn method(ind: &str) -> Item;
}
#[derive(Deserial
浏览 5提问于2020-11-30得票数 0
回答已采纳
站住！我是一个生锈的新手，在过去的几天里，我与一堆东西作斗争，但找不到任何关于这方面的信息。我有一个泛型结构(我已经简化了它来说明这个问题)。我希望能够用std::collections::HashMap、HashSet、List等创建一个结构，它可以做很多事情。我假设我需要暗示T必须实现一个新方法。使用特征？或者类似的东西，但是搜索只能找到基本的东西 public struct dude< T > {
data : std::sync::Arc< T >,
}
impl < T > dude< T > {
pub fn ne
浏览 9提问于2021-03-29得票数 0
2回答
在萨尔萨，有一个较高的等级的特征约束在一个性状上。我在函数定义上见过HRTB，但在特性上没有看到。什么意思？
pub trait Query: Debug + Default + Sized + for<'d> QueryDb<'d> {
...
fn query_storage<'a>(
group_storage: &'a <Self as QueryDb<'_>>::GroupStorage,
) -> &'a Arc<S
浏览 19提问于2022-01-02得票数 6
回答已采纳
我有以下代码：
trait Bar {
fn baz(&self, arg: impl AsRef<str>)
where
Self: Sized;
}
struct Foo;
impl Bar for Foo {
fn baz(&self, arg: impl AsRef<str>) {}
}
fn main() {
let boxed: Box<dyn Bar> = Box::new(Foo);
boxed.baz();
}
导致此错误：
error: the `baz` m
浏览 0提问于2018-08-13得票数 8
回答已采纳
我不知道如何为泛型迭代器指定迭代器输出类型的界限。在Rust 1.0之前，我曾经能够这样做：
fn somefunc<A: Int, I: Iterator<A>>(xs: I) {
xs.next().unwrap().pow(2);
}
但是现在，我不知道如何限制迭代器的Item类型。
fn somefunc<I: Iterator>(xs: I) {
xs.next().unwrap().pow(2);
}
error: no method named `pow` found for type `<I as std::iter::
浏览 1提问于2015-01-06得票数 12
回答已采纳
3回答
C++由于缺乏单独的模板编译而受到批评。C++模板是为(实际上)每个实例化编译的。对于锈病来说，关于单独汇编泛型的情况是怎样的？我的理解是，它的行为类似于C++，只不过实例化是在编译每个机箱时缓存的。是这样吗？
浏览 2提问于2014-09-17得票数 9
回答已采纳
4回答
这就是我的问题。我只是好奇关于限制可以传递给泛型函数或类的类型的共识是什么。我想我在某个时候读到过，如果您正在进行通用编程，通常最好保持打开状态，而不是试图关闭它们(不要想起源代码)。
我正在编写一个具有一些内部泛型函数的库，我觉得它们应该只允许与它们一起使用库中的类型，因为这就是我要使用它们的意思。另一方面，我不确定我的努力是否值得这样做。
有人可能有一些关于这个话题的统计资料或权威评论吗？我也对正确的意见感兴趣。希望这不会使这个问题完全无效:\
此外，这里是否有任何标签，可以等同于“最佳实践”？我没有看到具体的，但似乎它是有帮助的，能够提出所有的最佳实践信息，为一个特定的主题.也许不是，只
浏览 3提问于2011-05-18得票数 13
回答已采纳
1回答
我有这个类：public class My class <T extends Serializable>，我想将它扩展到一个新的泛型类public class Class2<T> extends My class<T>
它会产生绑定错配错误--我现在不记得规则了，而且无法访问这些材料，尽管几年前我获得了java see证书:(
浏览 5提问于2017-10-15得票数 0
回答已采纳
1回答
我发现在使用锈菌特性时会遇到困难，例如，哪种方法是正确的？
pub struct Cube<R>{
pub vertex_data: [Vertex;24],
pub asMesh: gfx::Mesh<R>
}
浏览 2提问于2015-05-04得票数 4
回答已采纳
trait A[T, This[_] <: A[T, This]]
case class B[T]() extends A[T, B]
<console>:8: error: type arguments [T,B] do not conform to trait A's type parameter bounds [T,This[_] <: A[T,This]]
case class B[T]() extends A[T, B]
这对我来说似乎很奇怪，因为它看起来应该是有效的？欢迎指导..。
谢谢
浏览 2提问于2015-07-02得票数 0
2回答
我试图从我的Rust程序中的一个进程中抽象出读写内存。以下是描述该问题的一些示例代码：
trait ProcessHandle {
// Create a new process handle from pid
fn new(pid: u32) -> Box<dyn ProcessHandle>;
// Read value from process of type T from the process
// (type T has an implicit Sized trait so we know how
// large the
浏览 0提问于2020-06-28得票数 0
下面是一个小代码示例(附带注意:我正在运行类型记录v3.8.3)：
interface IOptions<T> {
arg: T;
}
interface IExtraOptions extends IOptions<number> {
arg2: string;
}
type Func = <T, OptionsT extends IOptions<T>>(options: OptionsT) => T;
const f: Func = (options: IExtraOptions): number => {
r
浏览 5提问于2020-06-22得票数 1
回答已采纳
2回答
作为作业作业，我们必须实现一个附加类-- SortedList- -并使用链接的二进制搜索/排序树来实现它。
以下是接口的类标题(由教师提供)：
public interface SortedListInterface<T extends Comparable<? super T>> {
当我实现它的时候：
public class BinaryTree<T> implements SortedListInterface<T> {
错误出现如下：Bound mismatch: The type T is not a valid substitut
浏览 5提问于2015-11-30得票数 2
回答已采纳
我编写了下面的代码，但是我无法编写生命时间约束来工作并得到一个错误：
use futures::Future;
async fn foo<'a>(a: &'a str) -> &'a str {
let task = get();
f(a, task).await
}
async fn f<T>(v: T, task: impl Future<Output = T>) -> T {
if true {
v
} else {
task.awa
浏览 1提问于2021-01-18得票数 5
回答已采纳
2回答
我已经查看了源文件中的锈蚀库：，我看到了方法begin()：：
pub fn begin(self) -> Client<DataFrame, Sender<W>, Receiver<R>> {
let (reader, writer) = self.into_inner();
let sender = Sender::new(writer);
let receiver = Receiver::new(reader);
Client::new(sender, receiver)
}
所以..。我决定创建一些简单的包装函数
浏览 3提问于2015-06-27得票数 4
回答已采纳
我正在为一个游戏开发一些接口，到目前为止，我已经了解了以下接口定义：
public interface Player<A extends Action, R extends Result> { }
public interface Game<P extends Player<? extends Action, ? extends Result>> { }
但是，现在我想访问Game接口中的Game，我知道我可以通过向Game添加三种泛型来实现这一点，但这不应该是必需的，因为信息已经存在。
我想要的东西如下：
public interface
浏览 2提问于2014-03-19得票数 1
回答已采纳
1回答
我有一个复杂的代码块，我在下面概述了一下。基本上我需要初始化一个泛型，它总是一个结构体，并且该结构体已经默认实现了，但是编译器还是会报错：
fn create<T: Default>() -> T
{
T { ..Default::default() }
}
fn main()
{
let mut x = create::<Bob>();
}
收益率：
error[E0574]: expected struct, variant or union type, found type parameter `T`
--> macro.rs:7
浏览 40提问于2017-12-28得票数 1
回答已采纳
1回答
下面的代码()使我感到困惑：
struct Cacher<T>
where
T: Fn(i32) -> i32,
{
calculation: T,
value: Option<i32>,
}
我知道Fn是一个特性，但是通常一个特性没有争议，并且返回类型。我如何定义像Fn这样的特性
我试着看上去像 (实际上是FnOnce，但是Fn有FnMut绑定，FnMut有FnOnce绑定)，但我仍然很困惑。那个<Args>的意思是什么？那也是；但我不明白：
其中Fn(a, b, c) -> d本身就是不稳定的真实Fn特性的糖
浏览 2提问于2017-10-06得票数 4
回答已采纳
2回答
给定以下代码：
let DisplayImpl logger data =
data |> Seq.iter logger
printfn ""
let Working =
DisplayImpl (printfn "%O") [1;2;3]
DisplayImpl (printfn "%O") ["a";"b";"c"]
let NotWorking display =
display (printfn "%O") [1;2;3]
浏览 7提问于2011-12-08得票数 3
回答已采纳
1回答
我正在尝试用柴油实现一个通用的更新方法。一开始我试图传递一个对象
pub fn update<Model, Tab>(
conn: &PgConnection,
_: Tab,
current_model: Model,
mut new_model: Model,
) -> Result<Model, diesel::result::Error>
但这样做有一些困难，我把它改成了参考资料。
现在我有了这个代码：
pub fn update<'m, Model, Tab>(
conn: &P
浏览 12提问于2022-08-23得票数 0
我使用泛型已经有一段时间了，但只是以一种简单直接的方式。
现在我想这样做，我已经阅读和尝试了很多东西，比如使用接口和通配符，但都没有成功。我想知道是否有一种有效的方法可以通过Java泛型实现这一点，或者如果我误解了他们应该如何使用泛型。
假设我想创建一个泛型集合类，一个ArrayList，并且我想为各种不同的类型创建这样的数组列表，但重要的是，不同的类型可以确保实现特定的方法。然后我希望能够从我的泛型数组列表中调用该方法。
下面的代码非常简单，显然不会工作，我知道这一点。我已经尝试了很多比这更复杂的想法，但是我包含了以下代码，只是为了总结我正在尝试做的事情，并为答案提供一个示例。
请看Demo
浏览 2提问于2012-02-24得票数 1
回答已采纳
1回答
我需要一个特征，它允许我构造一个借用对象的对象，而这个对象又借用了一些东西。在下面的示例中，它是PaperBin。
trait GarbageBin<'a,'b>{
fn new(rubbish: &'b Paper<'a>) -> Self;
}
struct PaperBin<'a,'b> {
rubbish: &'b Paper<'a>
}
struct Paper<'a> {
matter: &'
浏览 19提问于2021-06-15得票数 0
回答已采纳
在Rust版指南中，它说在Rust 1.2中，。它给出了Rc<T>的例子，但没有给出一个完整的列表。还有哪些容器支持Rust 1.2+中的特征对象？
浏览 10提问于2019-07-05得票数 1
我正在尝试制作两种不同类型的适配器，它们做同样的工作，我不能重写这两种类型。
X有一个使用self的方法，所以运行时多态包装器是不适用的。唯一的选择是静态泛型方法。
struct X {}
impl X {
fn f(self, n: i32) {
println!("n = {}", n);
}
fn new() -> X {
X {}
}
}
struct AdapterX {
x: X
}
impl AdapterX {
fn uf(self, n: i32) {
浏览 2提问于2016-08-07得票数 2
关于下列代码：
struct Config<'a> {
query: &'a str,
filename: &'a str,
case_sensitive: bool,
}
impl<'a> Config<'a> {
pub fn new(args: &'a [String]) -> Result<Config, &'static str> {
if args.len() < 3 {
浏览 0提问于2019-06-01得票数 0
回答已采纳
我有以下代码：
struct Callable<P> {
callable: Box<FnMut(&P)>,
}
struct Parameters<'a> {
text: &'a str,
}
struct Context<'a> {
call: Callable<Parameters<'a>>,
}
Callable是可以通过引用P类型的参数来调用的东西。
Parameters包含对字符串的引用，因此它有一个泛型生存期参数是完全合理的。它基本上
浏览 2提问于2018-02-17得票数 0
回答已采纳
假设我有一些特质：
trait MyTrait {
fn function1(&self);
}
以及实现它的某种类型：
struct MyStruct {
number: i32,
}
impl MyTrait for MyStruct {
fn function1(&self) {
printn!("{}", self.number);
}
}
现在我有了另一种类型，它想要使用实现MyTrait的东西。不管他们是否拥有。从阅读中可以看出，实现这一目标的正确方法是让它使用Borrow<X>，而不是X或
浏览 0提问于2016-04-07得票数 9
回答已采纳
3回答
Scala是一种很棒的语言，但如果它有自己的运行时，我想知道如何改进？
也就是说，由于JVM的选择，做出了哪些设计选择？
浏览 3提问于2010-04-21得票数 21
回答已采纳
我在阅读scala默认库代码时发现了以下内容：
trait TraversableLike[+A, +Repr] extends Any
with HasNewBuilder[A, Repr]
with FilterMonadic[A, Repr]
with TraversableOnce[A]
with GenTraversableLike[A, Repr]
with Parallelizable[A, ParIterable[A]]
{
self =>
...
}
那到底是干什么用的？
浏览 1提问于2014-12-08得票数 1
回答已采纳
1回答
Swift泛型vs Any
、、、、
我在苹果网站上阅读了swift文档。有一个函数swapTwoValues，它交换两个任意给定值
func swapTwoValues1<T>(_ a: inout T, _ b: inout T) {
let temporaryA = a
a = b
b = temporaryA
}
现在，我想编写类似的函数，但不是使用T泛型类型，而是使用任何
func swapTwoValues2(_ a: inout Any, _ b: inout Any) {
let temporaryA = a
a = b
b = temporaryA
}
浏览 17提问于2017-07-26得票数 7
我正在尝试实现一个由泛型字段组成的结构，该字段的类型必须实现非消耗的"iter“方法(见下文)。
struct Node<T> {
key: T
}
impl<T> Node<T> where T: ?? {
fn do_stuff(&self) {
for e in self.key.iter() {
/* ... */
}
}
}
fn main() {
let n1 = Node { key: "foo".to_owned() }
浏览 7提问于2021-11-13得票数 2
考虑一下
fn where_clause<T, F>(mut f: F)
where
F: FnMut(&T),
{
}
fn inline<T>(mut f: FnMut(&T)) {
}
where_clause()编译得很好，而inline()给出了问题：
warning: trait objects without an explicit `dyn` are deprecated
添加dyn将导致：
the size for values of type `(dyn for<'r>
浏览 0提问于2021-08-03得票数 0
回答已采纳
trait MyTrait {
fn my_f(&self) ;
}
struct A {}
struct B {}
impl MyTrait for A {
fn my_f(&self) {
println!("A.my_f()");
}
}
impl MyTrait for B {
fn my_f(&self) {
println!("B.my_f()");
}
}
struct MyList<T: MyTrait> {
list: Ve
浏览 12提问于2022-11-10得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
