tkersey

import streamlit as st
import concurrent.futures # We'll do computations in separate processes!
import mymodule # This is where you'll do the computation

# Your st calls must go inside this IF block.
if __name__ == '__main__':
    st.write("Starting a long computation on another process")

    # Pick max number of concurrent processes. Depends on how heavy your computation is, and how
    # powerful your machine is.

tkersey

What is your setup?

Just chat.deepseek.com with prompts adapted from this gist.

Does it work in one-shot or I have to prompt it multiple times?

• For the qX_0 variants, they are actually quite straight-forward so deepseek can come up with a correct result in 1 shot.
• For the qX_K it's more complicated, I would say most of the time I need to re-prompt it 4 to 8 more times.
• The most difficult was q6_K, the code never works until I ask it to only optimize one specific part, while leaving the rest intact (so it does not mess up everything)

tkersey

// Backports the Swift 6 type Mutex<Value> to Swift 5 and all Darwin platforms via OSAllocatedUnfairLock.
// Lightweight version of https://github.com/swhitty/swift-mutex
// Feel free to use any part of this gist.
// Note: ~Copyable are not supported

#if compiler(>=6)

@available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
@available(macOS, introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
public struct Mutex<Value>: @unchecked Sendable {

tkersey

import os.lock

/// `CancellingContinuation` is built on top of `CheckedContinuation` and
/// provides some additional features. It can be used as a drop-in replacement,
/// providing a similar API.
///
/// ## Automatic cancellation
/// When the suspended task is cancelled the continuation is automatically
/// resumed with a `CancellationError`. After that, normally resuming the
/// continuation from client is silently ignored.

tkersey

AACustomByteStreamOpen
AAEntryACLBlob
AAEntryXATBlob
AAFieldKeySetGetKeyCount
AAHeaderGetKeyIndex
ABMultiValueGetCount
ABPersonViewController
ADCommonDefinitions
ADErrorAdUnloaded
ADErrorLoadingThrottled

tkersey

-- A concrete use case for the type which is to '(->)' as 'Day' is to '(,)'.
-- I call it "FunDay", but I don't know what its proper name is. I've been
-- trying to find a use for 'FunDay', and I think I've found a pretty neat one.

{-# LANGUAGE FlexibleContexts, FlexibleInstances, PolyKinds, RankNTypes, TypeSynonymInstances #-}
module Main where
import Test.DocTest

import Control.Monad.Except
import Control.Monad.Reader

tkersey

import Combine
import Foundation
import os

@MainActor public final class PollingDataModel<DataModels: Sendable> {
    private let logger = Logger(subsystem: "Polling", category: "PollingDataModel")

    private var pollingTask: Task<Void, Never>?
    private var currentlyPolling = false

tkersey

import Foundation

extension Task {
	static func sleep(until target: Date) async throws where Success == Never, Failure == Never {
		let duration = target.timeIntervalSinceNow
		try await Self.sleep(for: .seconds(duration))
	}
}

print("Waiting for 1s...")

tkersey

struct ReducedReplayAsyncStream<Element> {

    typealias Reduce = (_ partialResult: inout Element, _ nextResult: Element) -> Void

    private let storage: _Storage
    private var originalStream: AsyncStream<Element>

    init(
        bufferingPolicy limit: AsyncStream<Element>.Continuation.BufferingPolicy = .unbounded,
        initialResult: Element,

tkersey

extension Optional {
    func map<T>(
        transform: (Wrapped) async throws -> T
    ) async rethrows -> T? {
        guard case let .some(value) = self else { return nil }
        return try await transform(value)
    }
}