如何借用结构体的curried函数字段？
借用结构体的curried函数字段可以通过以下步骤实现：
- 首先，需要了解结构体（struct）是一种自定义数据类型，可以包含不同类型的字段。
- curried函数是一种函数编程概念，指的是将接受多个参数的函数转化为一系列只接受单个参数的函数。
- 在结构体中定义一个curried函数字段，可以使用如下的语法：
- 在结构体中定义一个curried函数字段，可以使用如下的语法：
- 在上述代码中，
MyStruct结构体包含一个名为CurriedFn的字段，该字段的类型为接受两个整数参数并返回整数结果的curried函数。 - 在使用该结构体时，可以对
CurriedFn字段进行赋值，例如： - 在使用该结构体时，可以对
CurriedFn字段进行赋值，例如： - 在上述代码中，
CurriedFn字段被赋值为一个函数，该函数接受两个整数参数并返回它们的和。 - 使用该结构体时，可以通过调用
CurriedFn字段来执行curried函数，例如： - 使用该结构体时，可以通过调用
CurriedFn字段来执行curried函数，例如： - 在上述代码中，通过调用
CurriedFn字段并传递两个整数参数，可以得到它们的和并将结果打印出来。
结合上述步骤，借用结构体的curried函数字段可以通过定义结构体中的字段并进行赋值，然后使用该字段来执行curried函数。这种技术可以在需要使用curried函数的场景中提供更灵活和可复用的代码逻辑。
对于腾讯云相关产品和产品介绍链接地址的推荐，由于不允许提及特定的云计算品牌商，因此无法提供相关信息。您可以在腾讯云官方网站上寻找相关产品和介绍。
相关·内容
如果结构的字段是私有的，那么是否可以将结构的部分作为可变的，另一部分作为不可变的。
fn main() {
let mut ecs = EntityComponentSystem::new();
for e_id in ecs.get_entities_with_component::<Velocity>().unwrap() {
let components = ecs.get_mut_components(e_id);
...
}
impl EntityComponentSystem {
...
p
浏览 0提问于2017-08-24得票数 8
回答已采纳
我试图在一个不变的作用域中调用一个可变方法，并给出：error[E0502]。
我已经理解了为什么会出现这个错误，但是我很难解决这个错误，或者如何进行另一种有效的方法。
这里是一个MCVE
struct A {
list: Vec<i8>,
has_three: bool,
}
impl A {
pub fn new() -> Self {
Self {
list: vec![1,2,3],
has_three: false,
}
}
pub fn mu
浏览 4提问于2020-07-04得票数 1
回答已采纳
我在Swift中有一个curried函数：
func counter(var val: Int)() -> () {
val++
println(val)
}
根据的说法，它应该等同于：
func counter(var val: Int) -> (() -> ()) {
func curryFunc() {
val++
println(val)
}
return curryFunc
}
但是，当我运行以下代码时：
let x = counter(3)
x()
x()
对于第一个，我得到4，4；而对于第二个，我得到4，5。
我使用的是Xco
浏览 3提问于2014-09-18得票数 2
3回答
我想用一个参数定义一个函数，该参数定义另一个以该参数作为名称的函数。
不起作用的例子：
(DEFUN custom (name op const var)
(DEFUN name (var) (op const var)))
问题是没有计算name，所以定义的函数总是被称为name。
我知道FUNCALL和APPLY可以动态计算参数，但我不知道如何正确调用FUNCALL DEFUN...。
浏览 1提问于2014-04-10得票数 1
1回答
看来，如果您引用了一个struct字段，那么整个struct就被认为是借来的。我成功地隔离了我想要做的事情，并树立了自己的榜样。我只想获得对B中某个字段的“只读”引用，以获得一些数据，然后修改B的另一个字段。有什么熟能生巧的方法吗？
struct A {
i: i32,
}
struct B {
j: i32,
a: Box<A>,
}
impl B {
fn get<'a>(&'a mut self) -> &'a A {
&*self.a
}
f
浏览 1提问于2014-08-26得票数 7
回答已采纳
这没有多大意义，因为不管if let如何，它都会返回相同的内容，但这是我遇到的问题的简明示例：
struct Data {
value: Option<i32>,
}
impl Data {
fn get(&mut self) -> Option<&mut i32> {
if let Some(val) = &mut self.value {
return Some(val);
}
return self.value.as_mut();
}
浏览 0提问于2019-06-02得票数 4
回答已采纳
我正在尝试使用React-Table，但遇到了一个问题：
我需要使用多个访问器，然后将这些值作为道具传递到一个自定义组件中，这样我就可以为每个用户呈现一个具有特定统计信息的模式。
我知道我只能将字符串或函数传递给React Table中的访问器，但我不确定如何将这些值作为属性返回。
我已经阅读了这个站点上的文档，虽然它提供了如何将事物组合到一个单元中的简单示例，但我仍然不知道如何处理将道具从多个访问器传递到一个单元中嵌入的自定义组件。
// sample data
const data = {
completionDate: "April 2, 2019 1:12 PM",
浏览 2提问于2019-04-04得票数 1
如何在Rust中的struct中声明"static“字段，最好使用默认值：
struct MyStruct {
x: i32, // instance
y: i32, // instance
my_static: i32 = 123, // static, how?
}
fn main() {
let a = get_value();
if a == MyStruct::my_static {
//...
} else {
//...
}
}
浏览 0提问于2014-10-24得票数 35
回答已采纳
我很难用借阅支票。
for item in self.xxx.iter() {
self.modify_self_but_not_xxx(item);
}
在我将一些代码重构到modify_self_but_not_xxx()之前，上面的代码起了作用。
error: cannot borrow `*self` as mutable because `self.xxx` is also borrowed as immutable
在保存对self的引用(例如，从for-loop中)时，我如何调用一个变异方法？
浏览 2提问于2014-12-06得票数 12
回答已采纳
struct Point {
x: u32,
y: u32,
}
struct Line<'a> {
start: &'a Point,
end: &'a Point,
}
在这里，start和end字段的唯一可能选项是使用与包含它们的Line变量相同或更长的生存期。我甚至无法想象如何使用终身说明符来表示字段的寿命更短。
为什么我必须在这里显式地指定生命周期？在这种情况下，省略是不可能的吗?如果是的话，原因是什么？
浏览 1提问于2015-01-05得票数 21
回答已采纳
Rust书(第2版)的第13章包含了一个简单的计算缓存的例子。Cacher将计算函数作为构造函数参数，并缓存结果-在第一次调用后，它不会再次调用该函数，而只是返回缓存的结果： struct Cacher<T>
where
T: Fn(u32) -> u32,
{
calculation: T,
value: Option<u32>,
}
impl<T> Cacher<T>
where
T: Fn(u32) -> u32,
{
fn new(calculation: T) -> Cach
浏览 14提问于2019-05-17得票数 0
密码
fn play(&self, game: &mut crate::game::Game) {
let player_in_turn: &Player = game.get_player_in_turn();
match player_in_turn.player_kind {
PlayerKind::AI => {
player_in_turn.do_random_move(&mut game);
}
_ => {
panic!(&#
浏览 4提问于2022-08-15得票数 1
回答已采纳
我正在尝试编写一个将json文件读入对象的通用代码。但这里似乎有些东西我错过了。
use serde::Deserialize;
use std::{error::Error, fs::File, io::Read};
pub fn from_file<'a, T>(filename: String) -> Result<T, Box<dyn Error>>
where
T: Deserialize<'a>,
{
let mut file = File::open(filename)?;
let m
浏览 11提问于2022-09-29得票数 2
回答已采纳
1回答
我正在尝试编写一个python扩展模块，其中一些函数是匆匆编写的，但我不太确定如何这样做。主要的困难在于，我不知道如何创建和返回PyFunction对象，以及如何将其参数的解析规则传递给它。有没有一种相当有效的方法来做到这一点，还是这种精神错乱？
从python方面来说，所需的语义应该是：
# given a function f(x, y)
f(a, b) -> result
f(a) -> f'
f'(b) -> result
浏览 1提问于2016-04-22得票数 0
回答已采纳
1回答
我正在编写函数文本，尽管与我见过的大多数示例不同，我是从一个多参数函数开始的，这个函数随后被匆匆处理。
我有：
//types
case class Thing1(v: Double)
case class Thing2(v: Double)
case class Thing3(v: Double)
type Multiplier = Double
//functions
val f1 = (t: Thing1, m: Multiplier) => Thing2(m * t.v)
val f2 = (t: Thing2) => Thing3(t.v)
我想要组合f1和f2来获得一
浏览 0提问于2017-06-16得票数 2
回答已采纳
3回答
我目前正在学习方案，我偶然发现了以下函数：
(define t (lambda (x) (lambda (y) x)))
(define f (lambda (x) (lambda (y) y)))
显然，它们是真和假作为函数的表示。我不知道为什么！
我有两个问题：
1)连续的lambda是什么意思？我只习惯于看到单个lambda，它用于向函数传递参数；
(define add
(lambda (x y)
(+ x y)))
通过调用(add 1 5)，我将获得6作为输出。
2)如何使用这些true和false函数？
浏览 0提问于2013-01-04得票数 3
回答已采纳
1回答
我想知道是否有一种很好的方法可以从文件中读取任何类型的结构。我能够用下面的函数编写一个文件。这允许我编写实现序列化的任何结构。我正在尝试做一些类似的事情，让读者使用泛型和结构化来推动沙漠化。然而，我似乎在讨论泛型和生命周期的问题。是否有读取任何类型结构的文件的方法？
extern crate bincode;
extern crate serde;
#[macro_use]
extern crate serde_derive;
use serde::{Serialize, Deserialize};
fn main() {
let filename = String::from(&#
浏览 10提问于2021-12-10得票数 0
回答已采纳
2回答
我了解*和**运算符的一般工作方式。下面的代码取自django的源代码
def curry(_curried_func, *args, **kwargs):
def _curried(*moreargs, **morekwargs):
return _curried_func(*(args + moreargs), **dict(kwargs, **morekwargs))
return _curried
我了解了args + moreargs部件的工作原理--最初传递给函数curry的非关键字参数和传递给curry返回的curried函数的参数组合在一起。我不明白的是
浏览 1提问于2013-06-27得票数 0
回答已采纳
1回答
我必须将以下函数转换为curried函数：
def findAllUsed(t: List[Task]): List[String] = {
t.flatMap(x => x.resources.map(x => x.FIELD_TO_SEARCH)).distinct
}
所以我这样做了：
def findAllUsed(t: List[Task], f: Resource => String): List[String] = {
t.flatMap(x => x.resources.map(f)).distinct
}
findAllUsed(tas
浏览 2提问于2017-07-14得票数 0
回答已采纳
2回答
我正在准备关于Scala和functional的演讲，我不确定有两个概念。
我使用前面在演示中介绍的一个函数：
def safe_division(x: Int, y: Int) : Option[Double] = {
if(y != 0)
Some(x / y.toDouble)
else
None
}
我创建了一个咖喱版本(如果我错了，请纠正我)：
val curried_safe_division: (Int) => (Int) => Option[Double] = {
(x) =>
(y) =>
i
浏览 4提问于2017-04-03得票数 3
回答已采纳
9回答
我正在尝试用python编写一个currying装饰器，我想我已经有了大致的想法，但仍然有一些情况不能正常工作……
def curry(fun):
cache = []
numargs = fun.func_code.co_argcount
def new_fun(*args, **kwargs):
print args
print kwargs
cache.extend(list(args))
if len(cache) >= numargs: # easier to do it expl
浏览 4提问于2012-02-27得票数 20
回答已采纳
我已经编写了一个通用的例程，它接受多个参数，并生成一个无限的斐波那契数列表，如下所示：
datatype 'a seq = Nil | Cons of 'a * (unit -> 'a seq) ;
fun fibo (a,b) = Cons(a, fn () => fibo(b,a+b));
val fib = fibo(0 , 1);
但问题是，我想使用currying技术来生成从0到1开始的斐波那契数的无限列表，我对currying的概念完全迷惑了。
用这个例子能给我一些关于currying概念的启发吗？如何在SMLNJ中使用currying生成fi
浏览 1提问于2013-11-01得票数 1
在rescript-json-组合器中的映射函数只接受未编译的函数，并且我们使用的函数是curried函数。
解决这个问题的最好方法是什么？我不知道是否有一种方法可以将咖喱函数转换为不受约束的函数，或者我是否应该创建一个接受咖喱函数的新映射函数。
一些我尝试过的解决方案：
以前：
input'(
list{
type'("text"),
on(~key="", "input", Json.Decode.map(v => v |> int
浏览 9提问于2022-10-06得票数 0
回答已采纳
尝试按照这个示例(取自scala )为所有集合创建通用的sum函数
trait Summable[A] {
def plus(a1: A, a2: A): A
def init: A
}
object IntSummable extends Summable[Int] {
def plus(a1: Int, a2: Int): Int = a1 + a2
def init: Int = 0
}
trait Foldable[F[_]] {
def foldLeft[A](xs: F[A], m: Summable[A]) : A
}
像这样实现foldLeft可以很好地工作
浏览 5提问于2014-02-06得票数 0
我开始学习锈菌，在实验中，我发现所有权如何应用于元组和数组，这是我不理解的。基本上，下面的代码显示了不同之处：
#![allow(unused_variables)]
struct Inner {
in_a: u8,
in_b: u8
}
struct Outer1 {
a: [Inner; 2]
}
struct Outer2 {
a: (Inner, Inner)
}
fn test_ownership(num: &mut u8, inner: &Inner) {
}
fn main() {
let mut out1 = Ou
浏览 4提问于2020-06-20得票数 7
回答已采纳
我的工作标题为curryTuple的组合器在功能社区中有通用的名称吗？
const curryTuple = f => tuple =>
foldl(g => x => g(x)) (f) (tuple);
const triple = [x => y => x + y, 0, [1,2,3,4,5]];
const foldl = f => acc => xs => xs.reduce((x, y) => f(x) (y), acc);
console.log(
curryTuple(foldl) (triple)
浏览 8提问于2020-09-16得票数 0
假设您有三个变量:收入、费用和利润，它们的类型都是Money (一种结构化类型，包含两个int字段，即美元和美分)。将收入减去费用的结果分配给利润。让我们做一个快乐的假设，即收入大于支出。然而，您可能仍然会发现支出的美分部分超过了收入。如果是这种情况，你将不得不从收入美元中“借用”1(即减去1)，并将其“给予”收入的美分(即加100!)以便正确地执行减法。
以下是我所拥有的，但它不起作用：
if (revenue.cents < expenses.cents)
{
revenue.dollars = revenue.dollars -1;
revenue.cents
浏览 0提问于2012-11-19得票数 2
回答已采纳
假设我有以下类和curried函数： case class A[T](data: T)
def foo[T](i: Int)(x: T): A[T] 那么有没有办法定义一个函数来只调用前面函数的第一部分呢？它将返回一个采用参数化类型的函数 def bar(i: Int) = ... // Can I call foo(i) in some way to return a function: [T](x: T) => A[T]??? 或者只是泛型类型不能以这种方式使用？
浏览 13提问于2021-04-07得票数 1
回答已采纳
我正在编写一个使用开放源码GDAL空间库的C++应用程序。GDAL附带了一个名为gdaldem的命令行可执行文件。它能够为数字高程模型生成HillShade栅格。
谁能告诉我如何通过GDAL API从代码中调用HillShade。我想直接调用API，而不是使用命令行可执行文件。
浏览 0提问于2014-10-29得票数 2
我用的是反应。我正在尝试动态地添加和删除输入字段。我正在尝试列一个对象列表，如
[
{"item": 1, "key": "RAM", "value": "8GB"},
{"item": 1, "key": "Color", "value": "Black"},
{"item": 1, "key": "Used For", "value":
浏览 2提问于2022-10-28得票数 1
回答已采纳
struct Object {
alive: bool,
name: String,
}
impl Object {
// the comments are what I thought the compiler was supposed to give
fn test(&mut self) {
let alive = &mut self.alive; // seems like there is mutable borrow here
self.name = String::from("dead"
浏览 1提问于2020-07-21得票数 0
1回答
我有一个宏
DECLARE_SOMETHING(X, Y) {X, Y}
由于宏回调，我想按以下两个步骤调用
CURRIED_DECLARE_SOMETHING(X)(Y)
但我怎么能做到呢？我真的不介意DECLARE_SOMETHING是否真的存在，我只是想为声明写一些像{X, Y}这样简单的东西，但称之为curried。
我尝试过这样的方法，但是我不知道如何用给Y的值来代替???。
#define CURRY(BODY, Y) BODY(Y)
#define CURRIED_DECLARE_SOMETHING(X) CURRY( DECLARE_SOMETHING(X, Y), ??? )
浏览 1提问于2018-04-23得票数 2
回答已采纳
我希望使用select中的Scan()函数来执行一个select语句，该语句可能(或不)返回多个行，并在函数中返回这些结果。
我是刚接触过Golang 泛型的人，我对如何实现这一点感到困惑。通常，我们将在Scan上使用*sql.Rows函数，并提供对我们希望将行读入的所有字段的引用，例如：
var alb Album
rows.Scan(&alb.ID, &alb.Title, &alb.Artist,
&alb.Price, &alb.Quantity)
其中相册是一个结构化类型，其中显示了这五个字段。
现在，为了不为我拥有的每
浏览 5提问于2022-04-19得票数 0
1回答
有没有办法在不丢失事件处理程序提供的this绑定的情况下，对函数部分应用附加参数。bind需要一个NULL值，因此将this作为第一个参数将丢失对DOM元素<button>Click</button>的引用。如果能像bind允许的那样提供额外的参数而不丢失对元素的引用，那就太好了
const button = document.querySelector('button')
function once(...args) {
console.log(...args, this) // {prop: 'val'}, event, `W
浏览 0提问于2019-09-04得票数 0
struct Foo01<'a> {
val: u32,
str: &'a String,
}
fn mutate_and_share_01<'a>(foo: &'a mut Foo01<'a>) -> &'a Foo01<'a> {
foo
}
fn mutate_and_share_02<'a>(foo: &'a mut Foo01<'a>) -> &'
浏览 2提问于2021-02-10得票数 1
1回答
假设我有一些函数，让我们称它为get-io-data，它从shell命令中获取数据。现在，我想要一个检查某些东西的函数：check-io-data。似乎应该用同样的方法来定义它，结果却是不同的。使用“传统”定义，我得到一个函数，根据计算时(get-io-data)的结果给出结果。但是，如果我使用curry，在定义时将得到一个依赖于(get-io-data)结果的函数。为了使它不那么混乱，下面是一个例子：
采用传统定义：
(define (check-io-data x) (equal? (get-io-data) x))
...
(check-io-data 0) ;; Now (get-io
浏览 0提问于2017-08-24得票数 2
回答已采纳
我正在阅读Scala with Cats这本书，可以在这里找到：
书中有一个我有疑问的代码样本。
基本上，代码中有一个额外的下划线，我不明白它的用途。是打字错误，还是下划线有什么用处？
import cats.Monoid
import cats.instances.int._ // for Monoid
import cats.instances.invariant._ // for Semigroupal
import cats.instances.list._ // for Monoid
import cats.instances.string._ /
浏览 10提问于2019-08-07得票数 0
回答已采纳
R.33让我困惑。有人愿意进一步解释一下吗？“再吃”的意思在这里似乎行不通。?？
R.33:取一个unique_ptr&参数来表示函数以这种方式使用unique_ptr重新部署小部件的原因，并强制函数调用的重新处理语义。
注意：“reseat”的意思是“使指针或智能指针引用不同的对象”。
示例void ( unique_ptr&)；//“将”或“可能”重新发送指针示例，错误的void (const unique_ptr&)；//通常不是您想要的
浏览 0提问于2018-10-15得票数 0
这个问题与我的代码无关。
我只想说明为什么我需要在function.func_name上进行懒惰的评估
我在代码中使用了一个curry装饰器
我通过修改func_name来显示急迫的参数。
这样，当我需要调试时，我就可以很容易地找出哪些参数已经被匆忙处理了。
我的curry示例
@curry
def f(a, b, c, flag_foo=True, flag_bar=False):
pass
>>> f
<function f at 0x100545398>
>>> f(1, flag_bar=True)
<functi
浏览 2提问于2013-05-01得票数 1
回答已采纳
1回答
驱动码
const join = (a, b, c) => {
return `${a}_${b}_${c}`
}
const curriedJoin = curry(join)
curriedJoin(1)(2)(3)
实现
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) return fn(...args)
return function(...nextArgs) {
return
浏览 4提问于2022-10-12得票数 1
回答已采纳
3回答
以下Scala代码适用于我：
def curry(s1: String)(s2: String): String = (s1 + " " + s2).toUpperCase
val uncurry = Function.uncurried(curry _)
println(uncurry("short", "pants"))
但是，以下代码没有：
def cat(s1: String, s2: String): String = (s1 + " " + s2).toUpperCase
def curry = Functio
浏览 3提问于2014-10-16得票数 0
回答已采纳
<Select
onChange={evt => myFunction('KEY', ['ARRAY', 'OF', 'VALUES'])(evt)}
..。
const myFunction = (key, funValues) => {
return (evt: React.ChangeEvent<HTMLSelectElement>) => {
const { values } = evt.target;
if (funVa
浏览 8提问于2019-11-20得票数 0
回答已采纳
我对scala很陌生，只是在玩一些代码。我从一个在网上找到的例子中创建了一个咖喱函数：
def adder(a: Int, b: Int) = a + b
var addto = (adder _ ).curried
而且起作用了。但是，当我尝试用匿名函数替换加法器时，就像..。
var addto = ({(a :Int, b: Int) => a + b} _ ).curried
我说错了：
error: _ must follow method; cannot follow (Int, Int) => Int
知道为什么这不管用吗？
浏览 3提问于2014-01-30得票数 1
回答已采纳
我有一个包含两个字段的结构，我想用另一个字段(不可变的借入)修改一个字段(可变的借入)，但是我从借入检查器中得到了一个错误。
例如，以下代码：
struct Struct {
field1: Vec<i32>,
field2: Vec<i32>,
}
fn main() {
let mut strct = Struct {
field1: vec![1, 2, 3],
field2: vec![2, 3, 4],
};
strct.field1.retain(|v| !strct.field2.
浏览 10提问于2016-04-02得票数 21
回答已采纳
2回答
我对js和函数式编程很陌生
我的问题如下
const orgFunc = (str, str2) =>{
return str + ' ' + str2;
}
const curryFunc = (str) =>
{
return orgFunc(str,'curried');
}
const interceptFunc = (fn) =>
{
return fn;
}
1 console.log("orgFunc",orgFunc('func','org'));
浏览 0提问于2018-04-18得票数 0
回答已采纳
我有这样的密码：
var test = [[1,1], "b","a"];
function findArray(element) {
return element == [1,1];
}
console.log(test.find(findArray));
它返回：
undefined
如何在测试数组中找到1,1数组？(不过，我不想翻阅它)
浏览 2提问于2019-10-02得票数 2
回答已采纳
1回答
在浏览了之后，我想做这个，但是我想知道如何使用函数数组。
这是我第一次尝试：
function curry<T extends any[]>(fn: (...args: T) => any) {
return function(...args: T) {
return args.length >= fn.length
? fn(...args)
: curry(fn.bind(undefined, ...args));
}
}
但是对于fn.bind，我得到的是“'this‘context’of type '(..
浏览 0提问于2020-09-15得票数 2
回答已采纳
2回答
是否有一种方法来调试在运行时动态定义的函数？
或者至少有一种简单的方法可以找出这个函数是在哪里产生的？
更新以提供更多细节：
我使用了inspect模块：
ipdb> inspect.getmodule(im.get_thumbnail_url)
Out[0]: <module 'django.utils.functional' from 'C:\java\python\Python25\Lib\site
-packages\django\utils\functional.pyc'>
ipdb> inspect.getsource(im.
浏览 1提问于2010-01-05得票数 4
回答已采纳
2回答
中间变量可绕过的借入错误
、、、
我试图在Rust中实现一个简单的桶形哈希表(只是为了实践)。哈希表结构定义为：
pub struct BucketedHashTable<K: Hash, V> {
buckets: Vec<Bucket<K, V>>,
size: usize,
}
其中Bucket是我单一链接堆栈的简单实现。
在表的几乎每一种方法(put、remove、get)中，我都将获取要插入密钥的桶(从其中移除、查找)，因此我提取了一种方法：
fn pick_bucket(&mut self, key: K) -> &mut Bucke
浏览 15提问于2021-12-29得票数 3
回答已采纳
抱歉，如果这很明显的话，我要从罗斯特开始。
我试图实现一个简单的组合关系(一个对象是另一个对象的单一所有者，内部对象在外部对象死后自动销毁)。
我原本以为它就像声明这样的结构一样简单：
struct Outer {
inner: Inner
}
据我所知，这正是我想要的:内部属性属于外部结构，当外部对象消失时，它将被销毁。
但是，在我的示例中，Inner类型来自库，并且具有一个生存期参数。
// This is illegal
struct Outer {
inner: Inner<'a>
}
// I understand why, I'm us
浏览 4提问于2021-12-03得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
