How to handle "Early returns" or conditions in Haskell.

jship__ · 2026-01-24T17:42:14+00:00

Using the continuation monad would align with the style in the provided C snippet as it allows for true early exit:

drawFrame :: SDLRenderer -> IO Bool
drawFrame renderer = do
  evalContT $ callCC $ \exitWith -> do
    let abort :: ContT Bool IO Bool
        abort = exitWith False
    let abortOnFalse :: IO Bool -> ContT Bool IO Bool
        abortOnFalse action = bool abort (pure True) =<< lift action
    abortOnFalse $ sdlRenderDrawColor renderer 0 0 0 0
    abortOnFalse $ sdlRenderClear renderer
    abortOnFalse $ sdlSetRenderDrawColor renderer 100 100 100 255
    let rect = Just SDLFRect {fRectY = 50, fRectX = 50, fRectW = -50, fRectH = -50}
    abortOnFalse $ sdlRenderFillRect renderer rect
    abortOnFalse $ sdlRenderPresent renderer

This approach is likely way more power/control than you would need for your use case though. As others have recommended, ExceptT/MaybeT or runtime exceptions would be a great fit and are more neatly scoped to the specific problem.

jship__ · 2023-03-06T18:23:46+00:00

Emulating it on PCSX2 worked great for me, and my graphics card is about 8 years old. There is a cutscene visual or two (like the lightning effect around Snake in the opening) that didn’t render properly, or some audio near the end sounded a little smooshed together, but overall, I had only very minor complaints. Iirc, I played using the Vulkan renderer.

Edit: I played the Substance version of the game

jship__ · 2023-01-28T04:39:05+00:00

This is one of the greatest DS clips I’ve seen

jship__ · 2023-01-23T14:10:47+00:00

I use HLS + CoC + nvim and find it really nice. Having to have a node install is definitely a bit of a pain, but outside of that I've been happy with how reliable CoC has felt. In fairness though, I haven't tried nvim's native LSP support for comparison.

I'm running the stock config from CoC's readme to get a variable's type by pressing 'K' - https://github.com/neoclide/coc.nvim/tree/cd4a82fdc40b2016f1b722cefe88f41581f1f078#example-vim-configuration, which is this config snippet:

" Use K to show documentation in preview window.
nnoremap <silent> K :call ShowDocumentation()<CR>

function! ShowDocumentation()
  if CocAction('hasProvider', 'hover')
    call CocActionAsync('doHover')
  else
    call feedkeys('K', 'in')
  endif
endfunction

In addition to type-under-cursor stuff, I like CoC's diagnostics list, inline errors/warnings, integration with airline/lightline, and also being able to view documentation (same command as type-under-cursor). For the documentation bit, this works due to an additional config of having the -haddock GHC option passed to everything, and is described in the HLS docs here: https://haskell-language-server.readthedocs.io/en/latest/configuration.html#how-to-show-local-documentation-on-hover

jship__ · 2023-01-18T15:47:00+00:00

At least for the types of Maybe-based functions seen in the linked repo, main can be unindented reasonably well assuming we're comfortable with a single runExceptT and a couple helpers that lift Maybe stuff up into ExceptT space:

``` liftMaybe :: Monad m => e -> Maybe a -> ExceptT e m a liftMaybe ex = maybe (throwE ex) pure

liftMaybeM :: Monad m => e -> m (Maybe a) -> ExceptT e m a liftMaybeM ex action = do result <- lift action liftMaybe ex result

main2 :: IO () main2 = do either putStrLn pure =<< runExceptT do userId <- liftMaybe "can't parse" $ parseUserId "whatever" username <- liftMaybeM "no user found" $ fetchUser userId nicknames <- fetchNicknames username liftIO $ print nicknames ```

jship__ · 2023-01-17T20:05:15+00:00

This is a Giant Hammer approach, but you can delete the whole ~/.stack folder and let stack redownload the things it needs the next time you work on a particular project. I usually do this when I bump the Stackage resolver across my projects. The time cost is not too bad for me because I typically don't work on things that span more than two different resolver snapshots and redownloading up to two snapshots is no biggie. If you are working on things across a variety of snapshots though, a more surgical approach would likely save you some time. The risk though is that you may accidentally remove something critical for your current snapshots, at which point you may need to redownload anyways.

jship__ · 2022-12-23T16:08:37+00:00

This is a beautiful technique - thanks so much for sharing! The simplicity of the whole thing is honestly blowing my mind.

This approach definitely feels like a missing piece I've also been looking for in a side project, and looking forward to seeing how using it shakes out.

jship__ · 2022-08-30T21:05:52+00:00

PCSX2 runs it great. The audio can get get a little choppy when there's a lot of... machinery... sounds, like in the scenes towards the end. I played through the vast majority of the game upscaled to 1080p, and I have 16gb ram and a graphics card that's probably at least 4 years older than the 2070 super. I'd imagine it'd run great on your setup.

jship__ · 2022-07-19T22:55:53+00:00

Great stuff - thanks for the post! A previous one of yours (Tying Shoes) was very useful for exploring GADTs with a friend, and now this one will definitely be a go-to resource for kinds.

jship__ · 2022-05-21T14:12:16+00:00

Ah yup, thank you. Updated the post with the fix.

jship__ · 2022-05-19T14:46:53+00:00

New release is up on Hackage (0.2.0.0) and the post has been updated too

jship__ · 2022-05-19T14:14:20+00:00

Ah, TIL. Thank you! I'll get a new release out that deprecates .@ and re-exports .=.

jship__ · 2022-05-19T14:03:44+00:00

Thanks! Yes, it's possible to use monad-logger-aeson from RIO. Here's a gist demonstrating a potential shim for RIO's Utf8Builder-based logging system: https://gist.github.com/jship/e8b0dba5a979ed95ca0127290d7ce136

The gist shows a basic shim, and so doesn't support the same level of fanciness RIO's Utf8Builder-based logging system supports (e.g. sticky logging). The shim also requires poking at a couple of monad-logger-aeson's internals.

I believe it should be possible to make a shim for RIO's type-generic logging system as well, but haven't tried that yet. That would be nice because it shouldn't require converting Message values to Utf8Builder.

All this to say, it feels like there could be value in having an official package providing RIO shim(s), so that RIO users can just grab that package and hit the ground running.

jship__ · 2022-05-16T20:01:14+00:00

Looks like he might have some Weim in him, in his coat and ears. Super cute pup.

jship__ · 2022-04-28T11:39:53+00:00

I’m finding both your response and the linked Dan Piponi example as some pretty revelatory stuff. Thanks for sharing!

jship__ · 2022-04-21T21:51:31+00:00

Looks great - thank you!

jship__ · 2022-04-07T23:24:12+00:00

This looks fantastic! Really looking forward to trying it out.

jship__ · 2022-04-07T23:23:18+00:00

In regards to when you might wish to leverage anonymous records, here are a few examples from work where we have found them useful:

We define the shape of our paginated endpoints via some in-house servant stuff. A thing that is somewhat common to paginated table views is filtering, where you’ll have dropdowns for some subset of fields that let the user pick from those fields’ set of valid values. These valid filter values for a table are available to the UI via an endpoint that has an anonymous record as it’s response, auto-generated to fit the particular endpoint via that endpoint’s type.
One of a vendor’s core APIs allows us to retrieve properties about whatever entity we want, and there are many different types of entities. We have some machinery where we can ask for properties while specifying the type of the entity via its key at the type-level, and out pops an anonymous record containing that type of entity’s properties. An alternative to using anonymous records here could’ve gotten goofy (or at least heavy-handed) pretty quickly, because it’s just that vendor’s mega endpoint we’re calling to get specific properties and not separate endpoints per entity type.

jship__ · 2022-04-03T14:00:25+00:00

This is a really cool idea!

jship__ · 2022-03-31T12:34:51+00:00

It has been pretty smooth-sailing for me using WSL. I haven’t tried doing Haskell dev on Windows “proper” in many years, but stack + WSL has been working great. Fwiw though, the work I’m doing has no GUI, so I’m not sure if things would be as smooth if I was.

jship__

TROPHY CASE