Tim Kersey 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)

Array

Algebraic Effects in JavaScript part 4 - Implementing Algebraic Effects and Handlers

This is the final part of a series about Algebraic Effects and Handlers.

Part 1 : continuations and control transfer
Part 2 : Capturing continuations with Generators
Part 3 : Delimited continuations
Part 4 : Implementing Algebraic Effects and handlers

So we've come to the core topic. The reality is that we've already covered most of it in the previous parts. Especially, in the third part, where we saw delimited continuations at work.

	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.

	// 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 {

	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.

	AACustomByteStreamOpen
	AAEntryACLBlob
	AAEntryXATBlob
	AAFieldKeySetGetKeyCount
	AAHeaderGetKeyIndex
	ABMultiValueGetCount
	ABPersonViewController
	ADCommonDefinitions
	ADErrorAdUnloaded
	ADErrorLoadingThrottled

	-- 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

	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,

	-- Yoneda --------------------------------------------------------------
	newtype Yoneda f a = Yoneda { runYoneda :: forall b. ((a -> b) -> f b) }

	instance Functor (Yoneda f) where
	fmap f y = Yoneda (\ab -> runYoneda y (ab . f))

	toYoneda :: Functor f => f a -> Yoneda f a
	toYoneda fa = Yoneda (\f -> fmap f fa)

	fromYoneda :: Yoneda f a -> f a