我认为目前的语言不存在这种支持.我认为我想做的事情可以通过"工作流引擎"来解决.但我对工作流程的问题通常是:

1. 声明/冗长,我发现一种更为简洁的命令式风格
2. 重量级,我会有很多简单但不同的小型状态机

我已经研究了在C#中序列化迭代器,但这并没有让我到达我想要的位置.我目前正在考虑在Boo中组装一个DSL,但不确定我是否能够在Boo中获得类似coroutine的行为,并且能够将其序列化.

例

这是我想做的有限虚构的例子.主要问题是,在例程中的任何时候,您可能需要获得用户输入.输入之间的时间可能很长,因此需要将服务状态序列化为磁盘.

    def RunMachine(user)
      var lever = user.ChooseLever()
      lever.Pull()
      var device = CreateDevice(user)
      machine.Add(device)
      machine.Run()

   def CreateDevice(user)
      var color = user.ChooseColor()
      var shape = user.ChooseShape()
      return Device(color, shape)

更新

我在CPython中有一个工作"引擎".它捎带在python中的迭代器/ yield支持上.所以代码看起来像这样:

def escape(self, you):        
    roll = yield self.game.rollDice(you)
    if roll < 5:
        self.caughtAction(you)                  

哪里rollDice可以打断.用一些用户动作.但是,CPython不会序列化迭代器.

由于游戏的整个状态可以定义为一系列命令,因此我将游戏状态序列化为协程开始的点,然后是剩余的命令列表.所以保存/恢复如下所示:

def dumpGameState(game):
    if gameState.partialState:
        return pickle.dumps({ 'partialState': game.partialState, 'partialInputs': game.partialInputs })

    return pickle.dumps(game)

def loadGameState(data):
    state = pickle.loads(data)

    if state.__class__ is …

写一堂课,我该如何实施

foo.send(item)？

__iter__ 允许像生成器一样迭代类,如果我想让它成为一个协程怎么办？

我正在尝试使用kotlin协同程序通过此处描述的方法访问room数据库,添加插件和依赖项,并在gradle中启用kotlin协同程序.

在gradle文件中:

    kotlin {
    experimental {
        coroutines 'enable'
    }
}
dependencies { implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.21" ...}

所以我suspend为dao类中的所有方法添加了关键字,如下所示:

道类

@Query("select * from myevent")
suspend fun all(): List<MyEvent>

@Delete
suspend fun deleteEvent(event: MyEvent)
...

并构建,然后得到这些错误

错误

e: C:\Users\projectpath\app\build\tmp\kapt3\stubs\debug\com\robyn\myapp\data\source\local\EventsDao.java:39: error: Deletion methods must either return void or return int (the number of deleted rows). public abstract java.lang.Object deleteEventById(@org.jetbrains.annotations.NotNull() ^ e: C:\Users\projectpath\app\build\tmp\kapt3\stubs\debug\com\robyn\myapp\data\source\local\EventsDao.java:41: error: Query method parameters should either be a type that can be converted into a database column …

已开始尝试在JUnit单元测试中使用kotlinx-coroutines-test(https://github.com/Kotlin/kotlinx.coroutines/blob/master/core/kotlinx-coroutines-test/README.md)但在我调用时遇到以下错误Dispatchers.setMain()

java.lang.IllegalArgumentException: TestMainDispatcher is not set as main dispatcher, have Main[missing, cause=java.lang.AbstractMethodError: kotlinx.coroutines.test.internal.TestMainDispatcherFactory.createDispatcher()Lkotlinx/coroutines/MainCoroutineDispatcher;] instead.

    at kotlinx.coroutines.test.TestDispatchers.setMain(TestDispatchers.kt:22)

我试过打电话Dispatchers.setMain(Dispatchers.Unconfined)也传入了val mainThreadSurrogate = newSingleThreadContext("UI thread").看起来似乎问题不是传递价值,而是mainDispatcher在接下来的测试中绊倒

public fun Dispatchers.setMain(dispatcher: CoroutineDispatcher) {
    require(dispatcher !is TestMainDispatcher) { "Dispatchers.setMain(Dispatchers.Main) is prohibited, probably Dispatchers.resetMain() should be used instead" }
    val mainDispatcher = Dispatchers.Main
    require(mainDispatcher is TestMainDispatcher) { "TestMainDispatcher is not set as main dispatcher, have $mainDispatcher instead." }
    mainDispatcher.setDispatcher(dispatcher)
}

我正在尝试使用 来存储价值DataStore。

class BasicDataStore(context: Context) :
    PrefsDataStore(
        context,
        PREF_FILE_BASIC
    ),
    BasicImpl {

    override val serviceRunning: Flow<Boolean>
        get() = dataStore.data.map { preferences ->
            preferences[SERVICE_RUNNING_KEY] ?: false
        }

    override suspend fun setServiceRunningToStore(serviceRunning: Boolean) {
        dataStore.edit { preferences ->
            preferences[SERVICE_RUNNING_KEY] = serviceRunning
        }
    }

    companion object {
        private const val PREF_FILE_BASIC = "basic_preference"
        private val SERVICE_RUNNING_KEY = booleanPreferencesKey("service_running")
    }
}

@Singleton
interface BasicImpl {
    val serviceRunning: Flow<Boolean>
    suspend fun setServiceRunningToStore(serviceRunning: Boolean)
}

在 a 中Service，尝试监视该值，以下是相应的代码：

private fun monitorNotificationService() { …

#include <coroutine>
#include <string>

template<typename T>
struct Awaiter final {
    bool await_ready() const { return false; }    
    void await_suspend(std::coroutine_handle<>) const {}    
    T await_resume() const { return T{}; }
};

struct ReturnObject {
  struct promise_type {
    ReturnObject get_return_object() { return {}; }
    std::suspend_never initial_suspend() 
        noexcept { return {}; }
    std::suspend_never final_suspend() 
        noexcept { return {}; }
    void return_void() {}
    void unhandled_exception() {}
  };
};

ReturnObject f()
{
    auto a1 = Awaiter<int>{};
    [[maybe_unused]] auto v1 = co_await a1; // ok    
    auto a2 …

如果我们有两个这样定义的流：

val someflow = flow {
    emit("something")
}

另一个流程定义如下：

val stateFlow = MutableStateFlow("some value")

是否可以将两个流组合成一个流，该流仅发出someflowor发出的最后一个值stateFlow？

这个想法是，stateFlow可能会在未来的某个时刻发出一个值，但在那之前我只想要someflow最后发出的任何值。在“组合”流程中，我想只获取 发出的第一个值someflow，但随后能够观察 上的其余更新stateFlow。

看起来这可以通过组合函数来完成，但我只想发出两个流之间的最新发出值，我不关心一个流的最后一个值是什么。

我开始尝试通过阅读文档和示例代码来学习 Boost::Asio 。我发现事情很难理解，特别是因为该模型看起来与协程相似。

然后我决定从这个cppcon 演讲开始学习协程。在链接的演讲中，在协程使用示例中给出了以下行。该示例是在 2014 年编写的，因此语法可能与 C++20 协程不匹配。

auto conn = await Tcp::connect.Read("127.0.0.1", 1337)

这感觉与 Boost::Asio 的既定目标相似。然而，在 Boost::Asio 文档的示例部分，有一个混合了 Boost::Asio 和 C++20 协程的示例。（我还不明白这个例子。）

Boost::Asio 和协程有什么关系？协程会取代 Boost::Asio 的部分内容吗？如果我不从事网络工作，我还应该使用 Boost::Asio 吗？std::async发送者/接收者提案在哪里适合这一切？

我正在制作一个闹钟应用程序，并使用 AlarmManager 来设置闹钟。在 AlarmManager 上运行 setAlarm 后，我使用 Room 保存每个闹钟，这样如果手机关闭，我可以稍后恢复它们。

我在设备启动后使用 Android 开发人员站点的指南运行 BroadcastReceiver： https: //developer.android.com/training/scheduling/alarms#boot

我的想法是通过 onReceive 方法从 Room 获取警报但是 Room 使用挂起乐趣来获取警报，但我无法在 onReceive 上运行它，因为 BroadcastReceiver 没有生命周期

我怎样才能达到类似的结果？

我正在使用 Python 3.10，我对asyncio.create_task.

在下面的示例代码中，无论我是否使用asyncio.create_task. 似乎没有什么区别。

如何确定何时使用以及使用与不使用相比asyncio.create_task有何优势？asyncio.create_task

import asyncio
from asyncio import sleep

async def process(index: int):
    await sleep(1)
    print('ok:', index)

async def main1():
    tasks = []
    for item in range(10):
        tasks.append(asyncio.create_task(process(item)))
    await asyncio.gather(*tasks)

async def main2():
    tasks = []
    for item in range(10):
        tasks.append(process(item)) # Without asyncio.create_task
    await asyncio.gather(*tasks)

asyncio.run(main1())
asyncio.run(main2())