{"@attributes":{"version":"2.0"},"channel":{"title":"Shorts on Francis Sunday","link":"https:\/\/codehakase.com\/shorts\/","description":"Recent content in Shorts on Francis Sunday","generator":"Hugo","language":"en-us","lastBuildDate":"Sat, 14 Jun 2025 00:00:00 +0000","item":[{"title":"Parsing, Not Guessing","link":"https:\/\/codehakase.com\/shorts\/parsing-not-guessing\/","pubDate":"Sat, 14 Jun 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/parsing-not-guessing\/","description":"

Markdown rendering in the terminal is usually done with string replacements or regex. This doesn\u2019t scale. Goldmark exposes a proper AST. Each node has type, position, and content. Rendering becomes walking the tree:<\/p>\n

\/\/ render renders the AST node to the writer<\/span>\n<\/span><\/span>func<\/span> (tr<\/span> *<\/span>terminalRenderer<\/span>) render<\/span>(w<\/span> io<\/span>.Writer<\/span>, source<\/span> []byte<\/span>, node<\/span> ast<\/span>.Node<\/span>) error<\/span> {\n<\/span><\/span>\treturn<\/span> ast<\/span>.Walk<\/span>(node<\/span>, func<\/span>(node<\/span> ast<\/span>.Node<\/span>, entering<\/span> bool<\/span>) (ast<\/span>.WalkStatus<\/span>, error<\/span>) {\n<\/span><\/span>\t\terr<\/span> :=<\/span> tr<\/span>.renderNode<\/span>(w<\/span>, source<\/span>, node<\/span>, entering<\/span>)\n<\/span><\/span>\t\tif<\/span> err<\/span> !=<\/span> nil<\/span> {\n<\/span><\/span>\t\t\treturn<\/span> ast<\/span>.WalkStop<\/span>, err<\/span>\n<\/span><\/span>\t\t}\n<\/span><\/span>\t\treturn<\/span> ast<\/span>.WalkContinue<\/span>, nil<\/span>\n<\/span><\/span>\t})\n<\/span><\/span>}\n<\/span><\/span><\/code><\/pre><\/div>
This is better. You don\u2019t need to guess whether a * means emphasis or a list. You know.<\/p>"},{"title":"import \"reflect\"","link":"https:\/\/codehakase.com\/shorts\/import-reflect\/","pubDate":"Tue, 10 Jun 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/import-reflect\/","description":"
An attempt at a concise explanation of Go\u2019s reflect<\/code> library.<\/p>\n
The reflect<\/code> package implements run-time reflection, allowing a program to check, amend and create arbitrary values of all kinds during implementation. Traditionally, Go is static, types are known and verified at compile time. The reflect<\/code> package allows you to escape from this static world. It operates primarily on two concepts: reflect.Type<\/code>, which represents the static properties of a type (like its name, methods, and struct fields), and reflect.Value<\/code>, which holds the actual underlying data and allows for dynamic reading and writing.<\/p>"},{"title":"TTYs","link":"https:\/\/codehakase.com\/shorts\/ttys\/","pubDate":"Tue, 13 May 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/ttys\/","description":"
Today I learned about the tty<\/code> command. It returns the current user’s terminal name.<\/p>\n
TTY(1) General Commands Manual TTY(1)\n<\/span><\/span>\n<\/span><\/span>NAME\n<\/span><\/span> tty \u2013 return user's terminal name\n<\/span><\/span>\n<\/span><\/span>SYNOPSIS\n<\/span><\/span> tty [-s]\n<\/span><\/span>\n<\/span><\/span>DESCRIPTION\n<\/span><\/span> The tty utility writes the name of the terminal attached to standard\n<\/span><\/span> input to standard output. The name that is written is the string\n<\/span><\/span> returned by ttyname(3). If the standard input is not a terminal, the\n<\/span><\/span> message \u201cnot a tty\u201d is written. The options are as follows:\n<\/span><\/span>\n<\/span><\/span> -s Do not write the terminal name; only the exit status is affected\n<\/span><\/span> when this option is specified. The -s option is deprecated in\n<\/span><\/span> favor of the \u201ctest -t 0\u201d command.\n<\/span><\/span>\n<\/span><\/span>EXIT STATUS\n<\/span><\/span> The tty utility exits 0 if the standard input is a terminal, 1 if the\n<\/span><\/span> standard input is not a terminal, and >1 if an error occurs.\n<\/span><\/span><\/code><\/pre><\/div>
One cool thing I found was if you get the tty of a terminal tab, you can push text to it. For instance, running echo "some text" > \/dev\/tty-{num}<\/code> will push the text some text<\/code> to the terminal with the tty.\n\"TTY<\/p>"},{"title":"GADTs for Type-Level Domain Logic","link":"https:\/\/codehakase.com\/shorts\/gadts-for-type-level-domain-logic\/","pubDate":"Wed, 07 May 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/gadts-for-type-level-domain-logic\/","description":"
I’ve been leveraging Generalized Algebraic Data Types (GADTs) in Haskell and found them exceptionally powerful for encoding domain-specific rules and state transitions directly into the type system. This is particularly useful for defining operations that are based on explicitly tagged types or state, and behave differently.<\/p>\n
Consider a scenario with distinct processing steps, each associated with specific data:<\/p>\n
{-# LANGUAGE GADTs #-}<\/span>\n<\/span><\/span>\n<\/span><\/span>module<\/span> StepProcessor<\/span> where<\/span>\n<\/span><\/span>\n<\/span><\/span>data<\/span> AuthData<\/span> =<\/span> AuthData<\/span> \n<\/span><\/span> { userId<\/span> ::<\/span> String<\/span>\n<\/span><\/span> , token<\/span> ::<\/span> String<\/span> \n<\/span><\/span> } \n<\/span><\/span> deriving<\/span> (Show<\/span>)\n<\/span><\/span>\n<\/span><\/span>data<\/span> ReviewData<\/span> =<\/span> ReviewData<\/span> \n<\/span><\/span> { documentId<\/span> ::<\/span> Int<\/span>\n<\/span><\/span> , comments<\/span> ::<\/span> String<\/span>\n<\/span><\/span> }\n<\/span><\/span> deriving<\/span> (Show<\/span>)\n<\/span><\/span>\n<\/span><\/span>data<\/span> Step<\/span> a<\/span> where<\/span>\n<\/span><\/span> AuthStep<\/span> ::<\/span> AuthData<\/span> -><\/span> Step<\/span> AuthData<\/span>\n<\/span><\/span> ReviewStep<\/span> ::<\/span> ReviewData<\/span> -><\/span> Step<\/span> ReviewData<\/span>\n<\/span><\/span>\n<\/span><\/span>validateAuth<\/span> ::<\/span> AuthData<\/span> -><\/span> IO<\/span> ()<\/span>\n<\/span><\/span>validateAuth<\/span> ad<\/span> =<\/span> putStrLn<\/span> $<\/span> "Validating auth for user: "<\/span> ++<\/span> userId<\/span> ad<\/span>\n<\/span><\/span>\n<\/span><\/span>runReview<\/span> ::<\/span> ReviewData<\/span> -><\/span> IO<\/span> ()<\/span>\n<\/span><\/span>runReview<\/span> rd<\/span> =<\/span> putStrLn<\/span> $<\/span> "Running review for doc: "<\/span> ++<\/span> show<\/span> (documentId<\/span> rd<\/span>) ++<\/span> " with comments: "<\/span> ++<\/span> comments<\/span> rd<\/span>\n<\/span><\/span>\n<\/span><\/span>processStep<\/span> ::<\/span> Step<\/span> a<\/span> -><\/span> IO<\/span> ()<\/span>\n<\/span><\/span>processStep<\/span> (AuthStep<\/span> payload<\/span>) =<\/span> validateAuth<\/span> payload<\/span>\n<\/span><\/span>processStep<\/span> (ReviewStep<\/span> payload<\/span>) =<\/span> runReview<\/span> payload<\/span>\n<\/span><\/span>\n<\/span><\/span>-- Example Usage:<\/span>\n<\/span><\/span>-- let authAction = AuthStep (AuthData "user123" "secret_token")<\/span>\n<\/span><\/span>-- let reviewAction = ReviewStep (ReviewData 456 "Looks good!")<\/span>\n<\/span><\/span>--<\/span>\n<\/span><\/span>-- processStep authAction <\/span>\n<\/span><\/span>-- processStep reviewAction<\/span>\n<\/span><\/span>--<\/span>\n<\/span><\/span>-- The following would be a compile-time error:<\/span>\n<\/span><\/span>-- processStep (AuthStep (ReviewData 789 "Wrong data!")) -- Type mismatch!<\/span>\n<\/span><\/span><\/code><\/pre><\/div>"},{"title":"Composable Parsers with Attoparsec","link":"https:\/\/codehakase.com\/shorts\/composable-parsers-with-attoparsec\/","pubDate":"Tue, 06 May 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/composable-parsers-with-attoparsec\/","description":"
I’ve been diving into Haskell’s attoparsec<\/a> and I’m impressed by how it simplifies building complex parsers. Here’s a quick example for a DSL snippet like "name=Some Name;age=42;"<\/code>, using Data.Attoparsec.Text<\/code>:<\/p>\n
import<\/span> Control.Applicative<\/span> ((<*<\/span>), (*><\/span>))\n<\/span><\/span>import<\/span> Data.Attoparsec.Text<\/span>\n<\/span><\/span>import<\/span> Data.Text<\/span> (Text<\/span>)\n<\/span><\/span>import<\/span> GHC.Generics<\/span> (Generic<\/span>)\n<\/span><\/span>\n<\/span><\/span>data<\/span> Person<\/span> =<\/span> Person<\/span> { name<\/span> ::<\/span> Text<\/span>, age<\/span> ::<\/span> Int<\/span> }\n<\/span><\/span> deriving<\/span> (Show<\/span>, Eq<\/span>, Generic<\/span>)\n<\/span><\/span>\n<\/span><\/span>personParser<\/span> ::<\/span> Parser<\/span> Person<\/span>\n<\/span><\/span>personParser<\/span> =<\/span> Person<\/span>\n<\/span><\/span> <$><\/span> (string<\/span> "name="<\/span> *><\/span> takeTill<\/span> (==<\/span> ';'<\/span>) <*<\/span> char<\/span> ';'<\/span>)\n<\/span><\/span> <*><\/span> (string<\/span> "age="<\/span> *><\/span> decimal<\/span> <*<\/span> char<\/span> ';'<\/span>)\n<\/span><\/span><\/code><\/pre><\/div>
This parser defines a Person<\/code> and then, using applicative style, consumes "name="<\/code>, takes characters until a semicolon (discarding the semicolon), then consumes "age="<\/code>, parses a decimal (discarding its trailing semicolon), and populates the Person<\/code> fields.<\/p>"},{"title":"Implementing Non-Copyable Embedded Structs","link":"https:\/\/codehakase.com\/shorts\/implementing-non-copyable-embedded-structs\/","pubDate":"Tue, 06 May 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/implementing-non-copyable-embedded-structs\/","description":"
While working with embedded structs, I learned that even implicitly promoted fields can be silently copied if the parent struct is passed by value. This becomes dangerous when the embedded struct holds resources like mutexes, buffers, or channels. To guard against this, I now utilise a noCopy<\/code> marker in the embedded struct itself, making any value-based use of the parent type inherently unsafe and detectable with vet or the race detector.<\/p>"},{"title":"Tmux sessionizer","link":"https:\/\/codehakase.com\/shorts\/tmux-sessionizer\/","pubDate":"Mon, 05 May 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/tmux-sessionizer\/","description":"
I’ve made some slight modifications to fit my dev setup.<\/p>\n
#!\/usr\/bin\/env bash\n<\/span><\/span><\/span><\/span>\n<\/span><\/span>if<\/span> [[<\/span> $#<\/span> -eq 1<\/span> ]]<\/span>; then<\/span>\n<\/span><\/span> selected<\/span>=<\/span>$1<\/span>\n<\/span><\/span>else<\/span>\n<\/span><\/span> selected<\/span>=<\/span>$(<\/span>find ~\/Dev ~\/Dev\/personal ~\/Dev\/work ~\/Dev\/personal\/projects ~\/Dev\/personal\/opensource ~\/Dev\/personal\/learning -mindepth 1<\/span> -maxdepth 1<\/span> -type d | fzf)<\/span>\n<\/span><\/span>fi<\/span>\n<\/span><\/span>\n<\/span><\/span>if<\/span> [[<\/span> -z $selected<\/span> ]]<\/span>; then<\/span>\n<\/span><\/span> exit<\/span> 0<\/span>\n<\/span><\/span>fi<\/span>\n<\/span><\/span>\n<\/span><\/span>selected_name<\/span>=<\/span>$(<\/span>basename "<\/span>$selected<\/span>"<\/span> | tr . _)<\/span>\n<\/span><\/span>tmux_running<\/span>=<\/span>$(<\/span>pgrep tmux)<\/span>\n<\/span><\/span>\n<\/span><\/span>if<\/span> [[<\/span> -z $TMUX<\/span> ]]<\/span> &&<\/span> [[<\/span> -z $tmux_running<\/span> ]]<\/span>; then<\/span>\n<\/span><\/span> tmux new-session -s $selected_name<\/span> -c $selected<\/span>\n<\/span><\/span> exit<\/span> 0<\/span>\n<\/span><\/span>fi<\/span>\n<\/span><\/span>\n<\/span><\/span>if<\/span> ! tmux has-session -t=<\/span>$selected_name<\/span> 2> \/dev\/null; then<\/span>\n<\/span><\/span> tmux new-session -ds $selected_name<\/span> -c $selected<\/span>\n<\/span><\/span>fi<\/span>\n<\/span><\/span>\n<\/span><\/span>if<\/span> [[<\/span> -n $TMUX<\/span> ]]<\/span>; then<\/span>\n<\/span><\/span> tmux switch-client -t $selected_name<\/span>\n<\/span><\/span>else<\/span> \n<\/span><\/span> tmux attach-session -t $selected_name<\/span>\n<\/span><\/span>fi<\/span>\n<\/span><\/span><\/code><\/pre><\/div>"},{"title":"Scripting a self-updating Github Readme","link":"https:\/\/codehakase.com\/shorts\/scripting-a-self-updating-github-readme\/","pubDate":"Thu, 01 May 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/shorts\/scripting-a-self-updating-github-readme\/","description":"
\"Github<\/p>\n
I took inspiration from Simon Willison’s blog<\/a> to utilise Github Actions for this. The Github Action<\/a> calls a script<\/a> that:<\/p>\n
I recently updated the README 1<\/a><\/sup> on my Github profile<\/a> to add a new blog post entry, which made me realise this manual process was a good candidate for automation.<\/p>\n
I came across tmux-sessionizer<\/a> today, and this has become handy in how I’m managing tmux sesisons. For my workflow, I added an alias that’ll launch tmux-sessionizer<\/code>.\n\"tmux-sessionizer\"<\/p>\n