kbridge

This is a random thought, don’t take it very seriously…

Most of our code is declarative. I don’t mean programming paradigms (because in that sense, most code would be imperative). I mean the way we write and organize it.

Adding a new feature usually requires modifying code in many places. Which…

• makes it harder for readers to infer the original author’s intent.
• makes it harder for maintainers to reason, because they have to navigate among different locations, especially when they don’t have an IDE with “Go To Definition” functionality.
• even makes meticulous programmers crazy because sometimes they may spend an unreasonable amount of time deciding where a new class member should go (add it to last, adapt an alphabetical order, or group it around members of a similar functionality?).

kbridge

Understanding the Phases Applicative

While I was researching how to do level-order traversals of a binary tree in Haskell, I came across a library called tree-traversals which introduced a fancy Applicative instance called Phases. It took me a lot of effort to understand how it works. Although I still have some unresolved issues, I want to share my journey.

Note: I was planning to post this article on Reddit. But I gave up because it was too long so here might be a better place.

See the discussion.

Note: This article is written in a beginner-friendly way. Experts may find it tedious.

kbridge

import Control.Monad
import Control.Monad.Trans.Class -- from `transformers`
import Control.Monad.Trans.Maybe -- from `transformers`
import Data.IORef

main :: IO ()
main = do
  i <- newIORef (0 :: Int)
  void $ runMaybeT $ forever $ do
    n <- lift (readIORef i)

kbridge

#include <iostream>
#include <type_traits>

class Bird
{
public:
    virtual ~Bird() = default;
};

class IFly

kbridge

#include <iostream>
#include <version>

#ifdef __cpp_lib_print
#	include <print>
#endif

#ifdef __cpp_lib_expected
#	include <expected>
#	include <system_error>

kbridge

#include <windows.h>

#include <iostream>
#include <sstream>
#include <string>
#include <utility>

#include <intrin.h>
#include <stdint.h>

kbridge

#include <format>
#include <iostream>
#include <string>
#include <string_view>

class Factor
{
public:
	Factor(std::string_view representation) :
		m_representation(representation)

kbridge

#include <iostream>
#include <random>
#include <string>

std::string get_random_string(size_t n)
{
	std::random_device device;
	std::default_random_engine::result_type seed = device();
	std::default_random_engine engine(seed);
	std::uniform_int_distribution<int> distribution('a', 'z');

kbridge

module Puzzle = struct
  let (+) a b =
    let rec work accum base remain =
      if remain = 0
      then accum
      else work
        (Int.add accum (remain mod b * base))
        (base * 10)
        (remain / b)
    in

kbridge

// please link with "runtimeobject.lib"

#include <roapi.h>
#include <winstring.h>

#include <windows.foundation.h>

#include <stdio.h>
#include <stdlib.h>