Maynard

@quelklef.bsky.social

44 Followers 42 Following

Maynard

Screenshot of Haskell code reading as follows

-- Law: if 'value > 0' then 'hadPositive = True'
data Target = Target
{ value :: Int
, hadPositive :: Bool
}

get :: Target -> Int
get = value

set :: Int -> Target -> Target
set n (Target { value, hadPositive }) =
Target { value = n
, hadPositive = hadPositive || (n > 0)
}

Screenshot reading as follows. The use of the phrase computation or computation result is not necessary, as any value can be though of as the trivial computation which produces itself.

Screenshot of the following string diagram:

-- const currentTime --Time-- map format --String-- map length --Int--

a diagram consisting of a rectangle and three lines. Two lines, labelled "a" and "b", go into the rectangle, labelled "f". The third line comes out of the rectangle

Screenshot of code reading as follows

Very rough module architecture:

╭───────────────╮ ╭───────────────────────╮ ╭─────────╮
│ launchWebHook │────────────────────────────────────│ tryConsumeStripeEvent │───│ onEvent │
│ │───╮ ╭─│ │ ╰─────────╯
╰───────────────╯ │ ╭────╮ ╭──────────────────╮ │ ╰───────────────────────╯
╭─────────────────╮ ╰─│ DB │──│ replayUnconsumed │─╯
│ fetchFromStripe │───│ │ ╰──────────────────╯
╰─────────────────╯ ╰────╯

Wires indicate the flow of a Stripe Event

Screenshot of code. The code consists of a function signature and a documentation comment. The doc comment reads:

"On incoming event, pass control off to a function. Very `ContT`-like. The mapper function is called **once per listener per event**"

The function signature is as follows:

control :: forall a b. (a -> (b -> Effect Unit) -> Effect Unit) -> Channel a -> Channel b

The doc comment also includes a diagram, showing how calling `control` results in a channel that sits between the input channel and any newly-added listeners.

A diagram for the semantics of a hypothetical alternative "map'" operation over an FRP stream, which applies the mapper function once per event instead of once per listener per event

a diagram of the semantics of a "map" operation on an FRP event channel

Diagram for a hypothetical "purchase credit" flow. The flow proceeds like this:

- User clicks "buy credit" button
- Button invokes a callback
- Callback invokes a PaymentMaker object
- The PaymentMaker object makes the payment to Stripe
- The PaymentMaker object also registers a listener with the webapp websocket
- Stripe notifies the webserver of the payment
- The webserver sends confirmation to the websocket
- The websocket forwards the confirmation back to the PaymentMaker
- The PaymentMaker reports success to the button callback
- The button callback updates the credit display

Diagram of a second hypothetical credit-purchase flow on a webapp. The flow is as follows:

- User clicks "buy credit" button
- The button invokes a callback
- The callback makes a payment to Stripe
- The callback also registers a listener to the webclient websocket
- Stripe notifies the webserver
- The webserver sends a confirmation to the webclient websocket
- The websocket forwards the confirmation through the listener to the button callback
- The button callback updates the credit display in the webapp UI

Diagram of a hypothetical credit-purchase flow on a webapp. The flow is as follows:

- User clicks "buy credit" button
- The button invokes a callback
- The callback makes a payment to Stripe
- Stripe notifies the webserver
- The webserver sends a confirmation to the webclient websocket
- The websocket updates the webclient credit display, in the UI

screenshot of code reading as follows

// Simulate a shitty connection to support writing robust code
setInterval(() => {
if (this.wsc && Math.random() < 0.25) {
this.wsc.close();
}
}, 30 * 1000);

Screenshot of code reading as follows:

-- | Specify the final value of an arity-two function first
-- |
-- | ```
-- | on x f y = f y x
-- | on x f y = x # f y
-- | ```
-- |
-- | Mostly useful when using a "data-last" function and want to fix
-- | the "data" instead of the "argument"; eg,
-- |
-- | ```
-- | intersect :: Array a -> Array a -> Array a
-- | intersect a b = a # filter (on b elem)
-- | ```
on :: forall x y r. x -> (y -> x -> r) -> y -> r
on = flip flip -- :D

Screenshot of the following text:

Woke up at 9 today, got out of bed at maybe 9:30 … broke open a coconut, made coffee … at that point I was ready to work

Screenshot of code reading:

type StepM m a = (a -> a) -> m Unit -- Save me from this self-inflicted hell

Code reading as follows:

// Call me with Stripe Events!! Please, I am so hungry for Stripe Events!!
exports.onStripeEvent =
async function(aff, event) {

$Two consoles. On the left console, code reading as follows. main :: IO () main = run do withReturn \return -> void $ withFork \fork -> do word <- withTell \tell -> do tell "under" suffix <- fork ["stand", "state", "estimate"] tell suffix lift $ print word when ("e" `isSuffixOf` word) do void $ return () pure () On the right, output reading as follows. "understand" "understate"$

Console output of GHC breaking. The first line is:

Main.hs: internal error: interpretBCO: hit a CASEFAIL

$Two terminals The right terminal reads as follows. [1,1] [1,2] [1,3] [1,4] [1,5] The left terminal reads as follows. main :: Effect Unit main = do _ <- withFork \fork -> do told <- withTell \tell -> do tell [1] n <- lift $ fork [1, 2, 3, 4, 5] tell [n] lift $ Console.log (show told) pure unit pure unit where run :: forall m a. Monad m => ContT a m a -> m a run c = runContT c pure withTell :: forall m w. Monad m => Monoid w => ((w -> ContT w m Unit) -> ContT w m Unit) -> m w withTell block = run do mempty <$ block \w -> ContT \k -> append w <$> k unit withFork :: forall m a b. Monad m => ((Array a -> ContT (Array b) m a) -> ContT (Array b) m b) -> m (Array b) withFork block = run do singleton <$> block \choices -> ContT \k -> choices # traverse k # map join singleton :: forall a. a -> Array a singleton x = [x]$

Console output of some code sending messages to discord, getting rate-limited, delaying the appropriate amount, and continuing. Each line of output indicates how long it's waiting due to rate-limiting, and how many messages are waiting in queue.

screenshot reading "Delimited continuations have been described by performing CPS transformation twice"

$A screenshot of the following code: useFork \p1 k1 -> (useTell \p2 k2 -> tell p2 [1] \() -> fork p1 [1 .. 5] \n -> tell p2 [n] \() -> k2 () ) \told -> print told \() -> k1 ()$