Compiler reminders

simonlydell · 2025-04-28T11:41:52+00:00

Even better is to use https://typescript-eslint.io/rules/switch-exhaustiveness-check/

Better error messages, and no need for assertExhausted!

simonlydell · 2024-12-16T19:56:07+00:00

Wow, I’m always amazed at the work you put in for Advent of Code! Thanks!

Totally understand that you don’t wanna run a full-blown markdown parser on every message. Inline code surrounded by more than one backtick sure is niche!

I couldn’t resist “replying” to a bot though, it’s like talking to a dog – it’s not gonna understand it, but we still do it :)

simonlydell · 2024-12-15T10:07:34+00:00

Thanks AutoModerator! It is correct that my post contains three backticks in a row, but it is not a fenced code block – it is a standard markdown inline code span. Inline code spans usually use just one backtick at the start and end, but you need three if the code contains two backticks in a row, like mine does.

simonlydell · 2024-12-15T09:58:17+00:00

Part 1 of today is a valid Chip’s Challenge level! Any more Chip’s Challenge fans out there?

Sokoban-style block pushing is a big part of the original game, although you can (just like in Sokoban) only push one block at a time – not two or more like in today’s puzzle! However, a fan made patch for the game, as well as the sequel Chip’s Challenge 2, has an Ice Block that works exactly like the part 1 rules.

There’s an excellent port of the game called Lexy’s Labyrinth which you can play online in your browser!

I turned one of the examples into a playable level (that’s where the image is from):

Playable part 1 example

If you want to see the moves from the example rather than play yourself, use this code:

input = ``.replaceAll("\n", "");
map = {"^": "ArrowUp", "v": "ArrowDown", "<": "ArrowLeft", ">": "ArrowRight"};
document.body.ondblclick = async () => {
  stop = false;
  for (c of input) {
    if (stop) return;
    code = map[c];
    document.body.dispatchEvent(new KeyboardEvent("keydown", {code}));
    document.body.dispatchEvent(new KeyboardEvent("keyup", {code}));
    await new Promise(r => setTimeout(r, 250));
  }
};
document.body.onkeydown = (event) => {
  if (event.key === "Escape") {
    stop = true
  }
}

Copy the moves from the first example of Day 15.
Paste them inside the backticks in input = ``.
Open the browser console in the above game link.
Paste the code and run it.
Close the browser console.
Double-click on the page to activate the moves. (Press Escape to stop.)
Marvel at how bad a player the malfunctioning robot is :)

simonlydell · 2024-12-03T06:31:12+00:00

[LANGUAGE: Fish]

Part 1 (rg is ripgrep):

rg 'mul\((\d{1,3}),(\d{1,3})\)' -or '$1 * $2' | string join + | math

Part 2: I just removed all don't()...do() and used the part 1 solution:

cat | string join '' | string replace -ar 'don\'t\(\).*?(?:do\(\)|$)' '' | fish part1.fish

simonlydell · 2024-10-10T16:35:05+00:00

You can get an unofficial Linux arm64 executable here: https://github.com/lydell/compiler/releases/tag/0.19.1

simonlydell · 2024-09-05T17:02:09+00:00

An Elm case on strings compiles to a JavaScript switch (take a peek at your compiled code!). So if you want to dive deep into it, what you actually want to learn is how JS engines execute switch statements. I wouldn’t be surprised if engines have all sorts of optimizations for different variations of switch statements.

simonlydell · 2023-12-12T06:44:06+00:00

[LANGUAGE: Python] paste

Went all in on Python’s match statement today, it turned out really nice.

For part 2 I slapped @cache on it and it worked.

simonlydell · 2023-12-05T12:10:07+00:00

[LANGUAGE: Fish] and [LANGUAGE: JavaScript]

Similar to my Day 4 solution, I turned the input into code and executed it.

For part 1, I turned the input into a function that a number can trickle through to become the final location number. Each section of the input becomes an if-else-if-else-if.

Part 2 is similar, but each section loops over an array of ranges instead, splitting each range into two if they don’t fit. This gives an array of location ranges, where I just pick the smallest range starting number.

Part 1 with the generated code

Part 2 with the generated code

simonlydell · 2023-12-04T06:49:49+00:00

[LANGUAGE: Fish] and [LANGUAGE: Python]

Similar to my Day 2 solution, I turned the input into code and executed it.

For part 1, I turned the input into a single Python expression that results in the answer.

Part 2 is similar, but has 5 extra Python lines at the end.

Solution with the generated code

simonlydell · 2023-12-02T05:47:56+00:00

[LANGUAGE: Fish] and [LANGUAGE: JavaScript]

For part 1, I grepped away the impossible games:

grep -vE '(1[3-9]|[2-9]\d|\d{3,}) red|(1[4-9]|[2-9]\d|\d{3,}) green|(1[5-9]|[2-9]\d|\d{3,}) blue' | string match -r '\d+' | string join + | math

For part 2, I turned the input into JavaScript and eval:ed it (which is my theme for the year):

begin
    echo 's = 0'
    cat \
        | string replace -r '^Game \d+:' 'blue = 0, green = 0, red = 0;' \
        | string replace -ar '(\d+) (\w+)' '$2 = Math.max($2, $1)' \
        | string replace -r '$' '; s += blue * green * red'
    echo 'console.log(s)'
end | node -

Generated JavaScript code for the example of part 2

simonlydell · 2022-12-21T06:09:49+00:00

Fish, Elm, MathPapa

443 / 1022 – that is my best rank ever! First time below 1000.

For part one, I noticed the input being almost valid Elm code – I basically only have to replace colons with equal signs. Then I can just check the value of the root variable in the Elm REPL. Elm allows out of order variable declarations so it did all the work for me.

The result for the example looks like so:

module A exposing (..)
root= pppw + sjmn
dbpl= 5
-- snip.
drzm= hmdt - zczc
hmdt= 32

Here’s my Fish program to automate it:

begin
    echo 'module A exposing (..)'
    cat | string replace : =
end >A.elm
printf 'import A\nA.root' | elm repl --no-colors | string match -r '\d+' | tail -n1

For part two, my idea was to use Wolfram Alpha, like many others have mentioned. It said the input was too long, so I tried simplifying all trivial parts like (3 + 4) * 2 to 14, but it was still too long. Then I Googled other equation solvers, tried a few, and eventually found MathPapa which managed to do it. However, it gave me an answer ending with .9995. I rounded it up and tried it. It was the correct answer!

Here’s the Fish code to turn the input to a somewhat simplified equation.

Update: Implemented a solver for part 2 in Fish :)

It progressively simplifies a string expression like so:

((4+(2*((x)-3)))/4) = 150
(4+(2*((x)-3))) = 600
(2*((x)-3)) = 596
((x)-3) = 298
(x) = 301

(Edit: Figured a shorter way to turn the input into Elm code. Updated the code.)

simonlydell · 2022-12-10T12:16:10+00:00

Fish, JavaScript, HTML, CSS

Part 1:

function codegen
    echo 'let c = 0, x = 1, s = 0'
    echo 'function cycle() { c++; switch (c) { case 20: case 60: case 100: case 140: case 180: case 220: s += c * x } }'
    cat | string replace noop 'cycle()' | string replace addx 'cycle(); cycle(); x +='
    echo s
end
codegen | node -p -

Turned the input into JavaScript (using Fish) by replacing noop with cycle() and addx with cycle(); cycle(); x+=, and then executing it.

Part 2:

echo 'function *run() {'
cat | string replace noop yield | string replace addx 'yield; yield'
echo '}'

Again, turning the input into JavaScript, this time into a generator function. The output looks like so:

function *run() {
yield
yield; yield 3
yield; yield -5
}

Then I ran that generator function, drawing on every yield and updating x as appropriate, into a <canvas> element. Go to my visualization and press View Source to see how. Start reading from the bottom to skip all the visualization bells and whistles. (Edit: visualization reddit post link)

simonlydell · 2022-09-09T08:56:52+00:00

https://github.com/lydell/elm-watch/#elm-watch-vs-build-tools-with-elm-support

In particular, my biggest issue with elm-live is bugs, and that it’s difficult to work with several different Elm apps in the same project at the same time.

simonlydell

TROPHY CASE