标签: yield

目前我正在阅读David A. Black的"The Well-Grounded Rubyist",我坚持10.9章(枚举器和可枚举的下一个维度).我的问题是关于yield方法.yieldRuby上下文中单词的含义是什么？我的母语是俄语,谷歌翻译向我展示了一堆翻译变体,让我感到困惑.其中有一些:给予,带来,投降(放弃),生产,同意,遵守和许多其他人.

UPD:请注意这个事实,我试图理解Enumerator :: Yielder#yield方法的含义 ,但不是yield关键字本身.

UPD_2:我发现了有关枚举器的有趣文章:" Ruby中的懒惰枚举器 ".

我花了很长时间寻找有关time.h :: sleep()和pthread.h :: pthread_yield()之间差异的信息,但无法找到任何可靠的参考资料,所以我发布了这个问题.

time.h :: sleep()和pthread.h :: pthread_yield()之间有什么区别？

更新:

我问的原因是因为我使用sleep()来睡眠()每个单独的线程......当我有8个线程和4个线程时,我的应用程序开始出现问题.当我上网查看sleep()是否只影响每个线程时,我找不到任何好的引用来说明Sleep()是否影响整个进程,或者sleep()只影响单个线程.

基本上我想转换这个:

def data(block: T => Unit)

到Stream(dataToStream是执行此转换的假设函数):

val dataStream: Stream[T] = dataToStream(data)

我想这个问题可以通过延续来解决:

// let's assume that we don't know how data is implemented
// we just know that it generates integers
def data(block: Int => Unit) { for (i <- 0 to 10) block(i) }

// here we can print all data integers
data { i => println(i) }

// >> but what we really want is to convert data to the stream <<

// very dumb solution is …

这个问题提到了这个Enumerator::Yielder#yield方法.我之前没有使用它,我想知道在什么情况下它会有用.

当您想要创建无限的项目列表(例如Eratosthenes的Sieve)以及何时需要使用外部迭代器时,它是否主要有用？

我有一个像这样定义的生成器:

def lengths(x):
    for k, v in x.items():
        yield v['time_length']

它起作用,称之为

for i in lengths(x):
    print i

生产:

3600
1200
3600
300

这是正确的数字.

但是,当我这样称呼时:

somefun(lengths(x))

其中somefun()定义为:

def somefun(lengths):
    for length in lengths():  # <--- ERROR HERE
        if not is_blahblah(length): return False

我收到此错误消息:

TypeError: 'generator' object is not callable

我有什么误会？

我今天正在尝试这个问题,来自欧拉问题:

回文数字两种方式相同.由两个2位数字的乘积制成的最大回文是9009 = 91×99.

找到由两个3位数字的乘积制成的最大回文.

我考虑过它,它当然可以用for循环完成,但是我想使用Java 8,因为它打开了新的选项.

但首先,我不知道如何生成IntStream产生这样的元素,所以我仍然使用正常的for循环:

public class Problem4 extends Problem<Integer> {
    private final int digitsCount;

    private int min;
    private int max;

    public Problem4(final int digitsCount) {
        this.digitsCount = digitsCount;
    }

    @Override
    public void run() {
        List<Integer> list = new ArrayList<>();
        min = (int)Math.pow(10, digitsCount - 1);
        max = min * 10;

        for (int i = min; i < max; i++) {
            for (int j = min; j < max; j++) {
                int sum = i …

在处理我的Java应用程序时,我有一个简单的多线程案例(一个异步资源加载器线程和一个主线程等待加载器完成,用进度更新UI),我想通过调用来解决

while( !foo.isInitialized() ) {
     Thread.yield();
}

在主线程中.我知道有更强大的解决方案; 仍然,加载器不是由我设计的,它是一个基本上只读的库(我不能简单wait(),因为我无法让它发送给我notify();也就是说,它完成后不会死),我只需要等到加载完成.

Java doc说(注意这不存在于1.6文档中,并且是由1.7个文档添加的)

使用这种方法很少是合适的.

NetBeans警告我

方法yield()on的调用java.lang.Thread通常用于伪装同步问题,应该避免.

谷歌Codepro AnalytiX,OTOH说

Thread.yield()不应使用该方法,因为其行为在所有平台上都不一致.

我是否应该关注这些警告并尝试找到更好的解决方案(欢迎提出所有建议),还是应该将其视为"警告噪音"并抑制/忽略它们？

注意:我想到了使用sleep()(Is Thread.sleep(0)和Thread.yield()语句等效的明显可能性吗？值得一提); 仍然,如果yielding在持续睡眠中没有"奖励",为什么Java会提供它 - 那么它的实际有效用例是什么呢？

略有关联: Thread.yield()有更好的解决方案吗？&Thread.Sleep或Thread.Yield

的编译器生成实施的IEnumerator/ IEnumerable用于yield方法和吸气剂似乎是一个类,因此,被分配在堆上.但是,其他.NET类型例如List<T>专门返回struct枚举器以避免无用的内存分配.通过对C#In Depth帖子的快速概述,我认为没有理由说这也不是这里的情况.

我错过了什么吗？

如何使用 设置函数的类型call()？

我有这个功能：

export function apiFetch<T>(url: string): Promise<T> {
    return fetch(url).then(response => 
        {
            if (!response.ok) throw new Error(response.statusText)
            return response.json().then(data => data as T);
        }
    )  
}

这个函数可以像这样使用：

let resp = await apiFetch<ServerResponse>("http://localhost:51317/Task");

通过使用您在上面的代码段中看到的函数，它resp是正确的字符串类型。所以智能感知为我提供了ServerResponse界面的所有属性。

但是，必须在redux-saga不允许的工人内部调用此函数，异步函数：

function* refreshTaskSaga():any {
    yield takeEvery("TASK_REFRESH", workerRefreshTaskSaga);
}


function* workerRefreshTaskSaga() {
  //I need to call the function here
}

我尝试使用 yield + call 调用它，如redux-saga文档所述：

a) let resp = yield call(apiFetch, "http://localhost:51317/Task");
b) let resp = yield …

import contextlib
import time

@contextlib.contextmanager
def time_print(task_name):
    t = time.time()
    try:
        yield
    finally:
        print task_name, "took", time.time() - t, "seconds."


def doproc():
    x=1+1


with time_print("processes"):
    [doproc() for _ in range(500)]

# processes took 15.236166954 seconds.

什么时候doproc在使用这个装饰器时被执行？