one liner sanctuary

what you’re about to see is the peak of “spend x hours automating a task instead of x minutes”. over the last couple of months, whenever i’ve been faced with some sort of repetitive task with vague logic to go from input => output, i open a node.js REPL and scribble away. why??? cause it’s pretty fun :). here’s a set of one liners doing random text transformations (formatted for your viewing pleasure) that i’ve saved.

pub enum ControllerButtons {
    A,
    B,
    X,
    Y,
    LThumb,
    Thumb,
    Menu,
}

input

match self {
	ControllerButtons::A => write!(f, "A"),
	ControllerButtons::B => write!(f, "B"),
	ControllerButtons::X => write!(f, "X"),
	ControllerButtons::Y => write!(f, "Y"),
	ControllerButtons::LThumb => write!(f, "LThumb"),
	ControllerButtons::Thumb => write!(f, "Thumb"),
	ControllerButtons::Menu => write!(f, "Menu")
}

output

taking in an enum of ControllerButtons, i get back a match statement that writes to a formatter with the enum variant’s name

"match self {\n" +
	input
		.split("{")
		.at(-1)
		.split("}")[0]
		.split(",\n")
		.map((x) => x.trim())
		.filter((x) => x !== "")
		.map((x) => `\tControllerButtons::${x} => write!(f, "${x}")`)
		.join(",\n") +
	"\n}";

code

#include "Extras"
#include "OVR_CAPI.h"
#include "OVR_CAPI_Audio.h"
#include "OVR_CAPI_D3D.h"
#include "OVR_CAPI_GL.h"
#include "OVR_CAPI_Keys.h"
#include "OVR_CAPI_Vk.h"
#include "OVR_ErrorCode.h"
#include "OVR_Version.h"
#include "bindgen.rs"
#include "wrapper.h"
#include "Extras/OVR_CAPI_Util.h"
#include "Extras/OVR_Math.h"
#include "Extras/OVR_StereoProjection.h"

output

c #includes from a directory of headers, not much work here

(
	await fs.readdir("~/Downloads/ovr_sdk_win_32.0.0/LibOVR/Include", {
		recursive: true,
	})
)
	.filter((x) => x !== ".DS_Store")
	.map((x) => `#include "${x}"`)
	.join("\n");

code

ovrButton_A | ovrButton_B | ovrButton_RThumb | ovrButton_X | ovrButton_Y | ovrButton_LThumb | ovrButton_Enter

input

if state.Buttons & ovrButton__ovrButton_A as u32 != 0 { held.push(ControllerButtons::A); }
if state.Buttons & ovrButton__ovrButton_B as u32 != 0 { held.push(ControllerButtons::B); }
if state.Buttons & ovrButton__ovrButton_RThumb as u32 != 0 { held.push(ControllerButtons::RThumb); }
if state.Buttons & ovrButton__ovrButton_X as u32 != 0 { held.push(ControllerButtons::X); }
if state.Buttons & ovrButton__ovrButton_Y as u32 != 0 { held.push(ControllerButtons::Y); }
if state.Buttons & ovrButton__ovrButton_LThumb as u32 != 0 { held.push(ControllerButtons::LThumb); }
if state.Buttons & ovrButton__ovrButton_Enter as u32 != 0 { held.push(ControllerButtons::Enter); }

output

taking in a match pattern of every ovrButton, a check gets generated for each ovrButton that determines if it’s being held and pushes a related ControllerButtons enum variant to held

input
	.split(" | ")
	.map(
		(x) =>
			`if state.Buttons & ovrButton__${x} as u32 != 0 { held.push(ControllerButtons::${x
				.split("_")
				.at(-1)}); }`,
	)
	.join("\n");

code

Load L
Output

Load e
Output

Load b
Output

Load r
Output

Load o
Output

Load n
Output

Load NewLine
Output

Load J
Output

Load a
Output

Load m
Output

Load e
Output

Load s
Output

Halt

L, DEC 76
e, DEC 101
b, DEC 98
r, DEC 114
o, DEC 111
n, DEC 110
NewLine, DEC 10
J, DEC 74
a, DEC 97
m, DEC 109
s, DEC 115

plaintextoutput

for an assignment, i had to output my first and last name in a strange assembly language for a fake computer. completely automated it of course, but i truly have no idea how i wrote this

const name = "Lebron\nJames";

name
	.split("")
	.map((x) => [
		`Load ${x === "\n" ? "NewLine" : x}\nOutput\n`,
		`${x === "\n" ? "NewLine" : x}, DEC ${x.charCodeAt(0)}`,
	])
	.reduce(
		(acc, x, i, arr) => [
			i === arr.length - 1
				? [...acc[0], x[0], "Halt\n"]
				: [...acc[0], x[0]],
			[...new Set([...acc[1], x[1]])],
		],
		[[], []],
	)
	.flat()
	.join("\n") + "\n";

code

'(' => TokenKind::LeftParen,
')' => TokenKind::RightParen,
'{' => TokenKind::LeftBrace,
'}' => TokenKind::RightBrace,
',' => TokenKind::Comma,
'.' => TokenKind::Dot,
'-' => TokenKind::Minus,
'+' => TokenKind::Plus,
';' => TokenKind::Semicolon,
'*' => TokenKind::Star,
'!' if self.next_if_eq('=') => TokenKind::BangEqual,
'!' => TokenKind::Bang,
'=' if self.next_if_eq('=') => TokenKind::EqualEqual,
'=' => TokenKind::Equal,
'<' if self.next_if_eq('=') => TokenKind::LessEqual,
'<' => TokenKind::Less,
'>' if self.next_if_eq('=') => TokenKind::GreaterEqual,
'>' => TokenKind::Greater,
'/' => TokenKind::Slash,

input

Minus,
Plus,
Slash,
Star,
Bang,
BangEqual,
Equal,
EqualEqual,
Greater,
GreaterEqual,
Less,
LessEqual,

also input

match op {
	Operator::Minus => Some("-"),
	Operator::Plus => Some("+"),
	Operator::Star => Some("*"),
	Operator::BangEqual => Some("!="),
	Operator::Bang => Some("!"),
	Operator::EqualEqual => Some("=="),
	Operator::Equal => Some("="),
	Operator::LessEqual => Some("<="),
	Operator::Less => Some("<"),
	Operator::GreaterEqual => Some(">="),
	Operator::Greater => Some(">"),
	Operator::Slash => Some("/"),
}

output

this one is… complicated. this takes in a set of match arms that convert a character, or two, to a TokenKind and outputs a match statement that converts that TokenKind back to a string. it also takes a set of TokenKinds which are operators; the outputted match statement only cares about these operators

"match op {\n" +
	input
		.split("\n")
		.map((x) =>
			x
				.trim()
				.split(" => ")
				.flatMap((x) => x.split(" ")),
		)
		.map((x) =>
			x.length === 4 ? [[x[0], x[2].split("'")[1]].join(""), x[3]] : x,
		)
		.map(([x, y]) => [y.replace(",", ""), x.replaceAll("'", "")])
		.filter(([x, y]) =>
			keep
				.split("\n")
				.map((x) => x.trim().replace(",", ""))
				.includes(x.split("::")[1]),
		)
		.map(
			([x, y]) =>
				`\t${x.replace("TokenKind", "Operator")} => Some("${y}"),`,
		)
		.join("\n") +
	"\n}";

code

keywords.put("and",    AND);
keywords.put("class",  CLASS);
keywords.put("else",   ELSE);
keywords.put("false",  FALSE);
keywords.put("for",    FOR);
keywords.put("fun",    FUN);
keywords.put("if",     IF);
keywords.put("nil",    NIL);
keywords.put("or",     OR);
keywords.put("print",  PRINT);
keywords.put("return", RETURN);
keywords.put("super",  SUPER);
keywords.put("this",   THIS);
keywords.put("true",   TRUE);
keywords.put("var",    VAR);
keywords.put("while",  WHILE);

input

match token {
	"and" => Some(TokenKind::And),
	"class" => Some(TokenKind::Class),
	"else" => Some(TokenKind::Else),
	"false" => Some(TokenKind::False),
	"for" => Some(TokenKind::For),
	"fun" => Some(TokenKind::Fun),
	"if" => Some(TokenKind::If),
	"nil" => Some(TokenKind::Nil),
	"or" => Some(TokenKind::Or),
	"print" => Some(TokenKind::Print),
	"return" => Some(TokenKind::Return),
	"super" => Some(TokenKind::Super),
	"this" => Some(TokenKind::This),
	"true" => Some(TokenKind::True),
	"var" => Some(TokenKind::Var),
	"while" => Some(TokenKind::While),
}

output

taking in some java code that made a hashmap of token strings => token enum representations, i get back a match statement that does the same thing as the map

"match token {\n" +
	input
		.split("\n")
		.map((x) => x.trim())
		.filter((x) => x)
		.map((x) => x.split(".put(")[1].split(",")[0])
		.map(
			(x) =>
				`\t${x} => Some(TokenKind::${
					x.substring(1, 2).toUpperCase() +
					x.substring(2, x.length - 1)
				}),`,
		)
		.join("\n") +
	"\n}";

code

enum TokenType {
	// Single-character tokens.
	LEFT_PAREN, RIGHT_PAREN, LEFT_BRACE, RIGHT_BRACE,
	COMMA, DOT, MINUS, PLUS, SEMICOLON, SLASH, STAR,

	// One or two character tokens.
	BANG, BANG_EQUAL,
	EQUAL, EQUAL_EQUAL,
	GREATER, GREATER_EQUAL,
	LESS, LESS_EQUAL,

	// Literals.
	IDENTIFIER, STRING, NUMBER,

	// Keywords.
	AND, CLASS, ELSE, FALSE, FUN, FOR, IF, NIL, OR,
	PRINT, RETURN, SUPER, THIS, TRUE, VAR, WHILE,

	EOF,
}

input

enum TokenType {
	LeftParen,
	RightParen,
	LeftBrace,
	RightBrace,
	Comma,
	Dot,
	Minus,
	Plus,
	Semicolon,
	Slash,
	Star,
	Bang,
	BangEqual,
	Equal,
	EqualEqual,
	Greater,
	GreaterEqual,
	Less,
	LessEqual,
	Identifier,
	String,
	Number,
	And,
	Class,
	Else,
	False,
	Fun,
	For,
	If,
	Nil,
	Or,
	Print,
	Return,
	Super,
	This,
	True,
	Var,
	While,
	Eof
}

output

just properly turns a java enum to a rust enum with regards to capitalization

"enum TokenType {\n" +
	input
		.split("\n")
		.slice(2, -1)
		.map((x) => x.trim())
		.filter((x) => x && !x.startsWith("//"))
		.flatMap((x) => x.split(","))
		.map((x) => x.trim())
		.filter((x) => x)
		.map(
			(x) =>
				"\t" +
				x
					.split("_")
					.map((x) => x.charAt(0) + x.substring(1).toLowerCase())
					.join(""),
		)
		.join(",\n") +
	"\n}";

code

import i1 from "../../assets/viewfinder/1.jpg";
import i1l from "../../assets/viewfinder/1.jpg?lqip";
import i2 from "../../assets/viewfinder/2.jpg";
import i2l from "../../assets/viewfinder/2.jpg?lqip";
import i3 from "../../assets/viewfinder/3.jpg";
import i3l from "../../assets/viewfinder/3.jpg?lqip";
import i5 from "../../assets/viewfinder/5.jpg";
import i5l from "../../assets/viewfinder/5.jpg?lqip";
import i6 from "../../assets/viewfinder/6.jpg";
import i6l from "../../assets/viewfinder/6.jpg?lqip";
import i8 from "../../assets/viewfinder/8.jpg";
import i8l from "../../assets/viewfinder/8.jpg?lqip";
import i9 from "../../assets/viewfinder/9.jpg";
import i9l from "../../assets/viewfinder/9.jpg?lqip";
import i11 from "../../assets/viewfinder/11.jpg";
import i11l from "../../assets/viewfinder/11.jpg?lqip";
import i12 from "../../assets/viewfinder/12.jpg";
import i12l from "../../assets/viewfinder/12.jpg?lqip";
import i13 from "../../assets/viewfinder/13.jpg";
import i13l from "../../assets/viewfinder/13.jpg?lqip";
import i14 from "../../assets/viewfinder/14.jpg";
import i14l from "../../assets/viewfinder/14.jpg?lqip";
import i15 from "../../assets/viewfinder/15.jpg";
import i15l from "../../assets/viewfinder/15.jpg?lqip";
import i16 from "../../assets/viewfinder/16.jpg";
import i16l from "../../assets/viewfinder/16.jpg?lqip";
import i17 from "../../assets/viewfinder/17.jpg";
import i17l from "../../assets/viewfinder/17.jpg?lqip";
import i18 from "../../assets/viewfinder/18.jpg";
import i18l from "../../assets/viewfinder/18.jpg?lqip";

output

for a site i was working on, the images were pretty big and compression wasn’t desired. i used a vite plugin that generates low quality image placeholders so that you see stuff while images load. importing each image alongside another import with ?lqip at the end was super tedious, and is what this code solved

(await fs.readdir(path))
	.filter((x) => x.includes(".jpg"))
	.map((x) => x.replace(".jpg", ""))
	.sort((a, b) => parseInt(a) - parseInt(b))
	.map(
		(x) =>
			`import i${x.replace(
				"-",
				"",
			)} from "../../assets/viewfinder/${x}.jpg";\nimport i${x.replace(
				"-",
				"",
			)}l from "../../assets/viewfinder/${x}.jpg?lqip";`,
	)
	.join("\n");

code

c("hello world");
// h\*\*\*\* w\*\*\*\*

c("its crashing like a thousand waves");
// i\*\* c\*\*\*\*\*\*\* l\*\*\* a t\*\*\*\*\*\*\* w\*\*\*\*

output

wacky text censor thing, *‘s are escaped cause of discord

const c = (s) =>
	s
		.split(" ")
		.map(
			(w) =>
				w.charAt(0) +
				w
					.substring(1)
					.split("")
					.map((x) => "\\*")
					.join(""),
		)
		.join(" ");

code

honestly some of these things were faster to write than doing the manual equivalent. 98% more fun than doing stuff manually though!

if you wanna write one liners:

use a scripting language’s REPL:
- node.js
  - tab for autocomplete works
  - use template literals (`) for multi line input
  - your repl history gets saved in ~/.node_repl_history
- python
- i wouldn’t recommend anything other than a scripted dynamic language for this kind of stuff, the goal isn’t to write a sound program
get extremely familar with chainable array methods
- map, filter, reduce, etc are very short ways to preform the majority of common array operations
- easy to write what happens with each transformation
generally avoid mutation and prefer creating new values

one liner sanctuary

2/22/2025

have a question/comment? want to say hi?

you can also just contact me on discord, @`squisket`

one liner sanctuary

2/22/2025

have a question/comment? want to say hi?

you can also just contact me on discord, @squisket

you can also just contact me on discord, @`squisket`