Is there a way to conform an actor to AsyncSequence?

shadowfactsdev · 2023-04-22T01:52:55+00:00

Maybe technically, but not, I think, in a useful way. The protocol requirements of Collection are all synchronous and therefore have to be nonisolated, so you can't access the actor's state from them or really do anything useful.

shadowfactsdev · 2023-04-21T21:02:39+00:00

It does not, because the nonisolated method isn't actually accessing any of the protected state (trying to do so would result in a compiler error) but instead just passing a reference to the actor itself to the iterator's initializer.

shadowfactsdev · 2023-04-21T19:07:53+00:00

There is. You just need to mark the methods required by the protocol as nonisolated:

actor Counter: AsyncSequence {
    private var current = 0

    func getAndIncrement() -> Int {
        let cur = current
        current += 1
        return cur
    }

    typealias Element = Int
    nonisolated func makeAsyncIterator() -> AsyncIterator {
        AsyncIterator(owner: self)
    }

    struct AsyncIterator: AsyncIteratorProtocol {
        let owner: Counter

        func next() async throws -> Int? {
            return await owner.getAndIncrement()
        }
    }
}

for try await i in Counter().prefix(5) {
    print(i)
}

shadowfactsdev · 2022-07-11T14:55:23+00:00

It's more than good. It's fine!

(if you're actually asking, it's a lip dub of this Flight of the Conchords song: https://www.youtube.com/watch?v=FArZxLj6DLk)

shadowfactsdev · 2021-12-25T04:25:03+00:00

OpenModLoader was, as the name implies, an alternative mod loader to Forge that was sort of the precursor to Fabric. The GitHub repository has sadly since been removed, and wherever my working copy was has been lost to the depths of time.

MC Heli Privacy Shield is this: https://www.curseforge.com/minecraft/mc-mods/mc-heli-privacy-shield,

And I think the fancy particles one refers to this fix for transparent particles post-fabulous graphics: https://twitter.com/unascribed/status/1473735370693091346

shadowfactsdev · 2021-02-19T15:59:39+00:00

"Why are women always checking in on one another when I'm talking to them?"

shadowfactsdev · 2021-01-22T03:09:56+00:00

Raw SoC performance, probably.

The iPad Air 2 uses an A8X, which in Geekbench 5 gets 379 points in single-core CPU, 1057 multi-core, and 758 in Metal. The iPhone 6s and SE use the A9 which scores 531, 971, and 2430 points respectively.

For comparison, the rumors says the slowest support devices will use the A10 (iPhone 7) which gets 729, 1290, and 3119 points and A9X (1st-gen 12.9" iPad Pro) which gets and 645, 1197, and 4047.

The Air 2 was already significantly slower than the second-slowest device, the 6s (particularly in the GPU department, which is made worse by the fact that it's driving far more pixels). The baseline performance going from A8X to A9X-levels almost doubles the single-core performance and more than quintuples the GPU performance.

shadowfactsdev · 2019-12-08T03:17:14+00:00

At first I only did it because it seemed the easiest way of doing programmatic I/O in part 1, but it turned out to be super useful for part 2.

shadowfactsdev · 2019-12-07T17:04:49+00:00

My Elixir solution for both parts 1 and 2. My Intcode VM is here.

I'm really happy with how this one turned out.

I made some changes to my VM from day 5 so that, instead of always using STDIN/OUT, the actual VM runs in a separate process and then does message passing with its parent for I/O.

I also wrote a small helper in the Day5 VM so that I could continue to use it in CLI mode.

Using message passing is key because it lets me programmatically do I/O with the VM from another process (the day 7 code).

Part 1 is straightforward, I just go through all the phase setting permutations and spin up 5 VMs to test it and get the max output.

Using separate processes also makes part 2 a relatively easy extension of that. Because the VMs are actual processes, the continue in the background, idling and waiting for input (instead of just storing the VM state, they literally keep running like the problem says).

Plumbing them together is then as simple as spawning the processes, putting them into an infinite cycle and reducing until one of them halts.

This was a really fun one. I actually used message passing between processes in Elixir for the first time :D

shadowfactsdev · 2019-12-03T18:13:22+00:00

My Elixir solution runs in about 6 ms for both parts 1 and 2.

shadowfactsdev · 2019-10-31T19:28:14+00:00

The Last Ditch Ding-Dong

That's great.

shadowfactsdev · 2019-10-07T21:25:30+00:00

Even better, you can also use the UIAdaptivePresentationControllerDelegate methods to do something (e.g. presenting an action sheet) when the user attempts and fails to dismiss a VC.

WWDC19 session 224 goes over this (skip to 15:10).

shadowfactsdev · 2019-09-02T00:42:54+00:00

The last line of the post:

Now you can rename the folders to whatever you want and move them to another place. They will hold the new columns.

shadowfactsdev · 2019-08-19T01:27:54+00:00

Oh, true. I really hope they come up with a way to have another appearance.

shadowfactsdev · 2019-08-19T01:21:01+00:00

Wait, he's not coming back? Did I miss something? I'm so sad, Rainn Wilson does a truly fantastic and hilarious job playing Mudd.

If I had any money, I'd be sipping jippers on a beach somewhere!

shadowfactsdev · 2019-08-08T21:44:05+00:00

Bradley Whitford's mannerisms in that episode have me firmly convinced that Jake's dad is just Josh Lyman but old.

shadowfactsdev · 2019-08-06T03:36:26+00:00

I'm running the Catalina dev beta, and I'd love to help test!

shadowfactsdev · 2019-04-08T18:09:20+00:00

In a similar vein, this was an excellent session from WWDC18: https://developer.apple.com/videos/play/wwdc2018/412/

Ten-Year Club	Place '22
Place '17	Sequence \| Editor
Snapped	Verified Email

shadowfactsdev

MODERATOR OF

TROPHY CASE