michael 📈 👨‍💻

@mikedecr.computer

Low-latency quant finance R&D. Former political scientist, sometimes bike rider. Long form mikedecr.computer

hy code and output:

(import toolz [first second])
(require hyrule [->])

(defn which [lst]
(-> lst
(enumerate)
((curry filter (compose bool second)))
((curry map first))
(list)))

(which [False False True False True])

[2, 4]

Python console input and output:

>>> with Bind(1) as x:
... print(x)
...
1
>>> x
Traceback (most recent call last):
File "<python-input-12>", line 1, in <module>
x
NameError: name 'x' is not defined

$python code snip: from pick_your_ggplot_emulation_pkg import * def fnplot(data, *args): return sum(args, start=ggplot(data)) fnplot( data, aes(x="x", y="y"), geom_point(), geom_line() ) # vs... ( ggplot(data) + aes(x="x", y="y") + geom_point() + geom_line() ) # or... ggplot(data) + \ aes(x="x", y="y") + \ geom_point() + \ geom_line()$

$Screenshot of python code: @dataclass class CircuitNetwork: _circuits: list[Circuit] # idk if this is the best place for this method but oh well. def contains_link(self, a: Box, b: Box) -> bool: """True if a local circuit contains boxes A and B""" return any(a in circ and b in circ for circ in self._circuits) def attach(self, a: Circuit, b: Circuit) -> None: """Consolidates circuits A and B into a single circuit""" assert a != b, "Circuits must be distinct" assert a in self._circuits, f"Circuit {a=} is not in the network" assert b in self._circuits, f"Circuit {b=} is not in the network" self._circuits.remove(a) self._circuits.remove(b) self._circuits.append(a.union(b)) def get_circuit(self, pt: Box) -> Circuit: """Returns the circuit containing provided Box""" for circ in self._circuits: if pt in circ: return circ$

def attach_interval(lst: list[Interval], new: Interval) -> list[Interval]:
"""Collapse interval `new` to the last element of `lst` if possible, otherwise append."""
if len(lst) == 0:
lst.append(new)
return lst
if (collapsed := maybe_collapse_intervals(lst[-1], new)):
lst[-1] = collapsed
else:
lst.append(new)
return lst

python code:

def maybe_collapse_intervals(left: Interval, right: Interval) -> tuple[Interval, ...] | None:
"""Return collapsed interval if possible, or None"""
a, b = left
x, y = right
if a <= x <= y <= b: # left contains right
return (a, b)
elif x <= a <= b <= y: # right contains left
return (x, y)
elif a <= x <= b <= y: # left straddles right lower bound
return (a, y)
elif x <= a <= y <= b: # left straddles right upper bound
return (x, b)
else:
return

$Python code: @app.command() def day_5_2(test: Flag("--test") = False): data_path: Path = Data(5, test=test) intervals_lst: list[Interval] = [] with open(data_path, "r") as f: for line in f: if line == "\n": break interval: Interval = tuple(eval(chr) for chr in line.strip().split("-")) intervals_lst.append(interval) # with the intervals sorted, we can do this w/ reduce # fn: combine RIGHT w/ tail of LEFT or append RIGHT to LEFT intervals_lst.sort() collapsed_intervals: list[Interval] = reduce(attach_interval, intervals_lst, []) result: int = sum(1 + (right - left) for left, right in collapsed_intervals) print("solution:", result) def attach_interval(lst: list[Interval], new: Interval) -> list[Interval]: """Collapse interval `new` to the last element of `lst` if possible, otherwise append.""" if len(lst) == 0: lst.append(new) return lst end = lst.pop(-1) if (collapsed := maybe_collapse_intervals(end, new)): lst.append(collapsed) else: lst.append(end) lst.append(new) return lst def maybe_collapse_intervals(left: Interval, right: Interval) -> tuple[Interval, ...] | None: """Return collapsed interval if possible, or None""" if left[0] <= right[0] <= right[1] <= left[1]: # left contains right return left elif right[0] <= left[0] <= left[1] <= right[1]: # right contains left return right elif left[0] <= right[0] <= left[1] <= right[1]: # left straddles right lower bound return (left[0], right[1]) elif right[0] <= left[0] <= right[1] <= left[1]: # left straddles right upper bound return (right[0], left[1]) else: return$

screenshot of python code:

# this is the classical definition of map
def map(fn, xs: list):
if len(xs) == 0:
return []
else:
return [fn(xs[0]), *map(fn, xs[1:])]

# but you can implement as a reduce
from functools import reduce

def map(fn, xs: list):
return reduce(_as_binary_op(fn), xs, list())

# casting func into a binary operation
def _as_binary_op(fn):
def binary_op(accum: list, x):
accum.append(fn(x))
return accum
return binary_op

map(str.upper, ["a", "b", "c"])
# ['A', 'B', 'C']

$text in the R console: R > by_sex = \(x) group_by(x, sex, .add = TRUE) R > mean_mass = \(x) summarize(x, mass = mean(body_mass_g)) R > penguins |> by_sex() |> mean_mass() # A tibble: 3 × 2 sex mass <fct> <dbl> 1 female 3862. 2 male 4546. 3 NA NA$

Screenshot from the text of the blog post:

More abstractly, what I want is more separation of functions from data in the R pipeline style.
In some situation, I want to pass data `x` to functions `f`, `g`, and `h`.
But instead of writing this:

```{r}
#| eval: false
x |>
f(...) |>
g(...) |>
h(...)
```

I want to write something like this:

```{r}
#| eval: false
# first argument omitted from each of these expressions
pipeline = compose(f(...), g(...), h(...))

# supply data to the ultimate function call
x |> pipeline()
```

`pipeline` is a function that captures unevaluated function calls on `f`, `g`, and `h` with their first arguments omitted.
Then I pass data `x` such that the data pass through the first argument of each function in the chain.

Why do I want this?
Because it should be easier to build a pipeline of expressions that can be re-used on different datasets.
I am thinking specically of examples like this:

```{r}
#| eval: false
# I could evaluate this function as-is
x |> pipeline()

# and I could also drop in extra steps j and k
x |> j() |> pipeline()
x |> k() |> pipeline()
```

Screenshot of R code that reads:

library(dplyr)
library(palmerpenguins)

# how a normal pipeline looks
mass_stats <- penguins |>
group_by(species, island) |>
summarize(
mean_body_mass = mean(body_mass_g, na.rm = TRUE),
sd_body_mass = sd(body_mass_g, na.rm = TRUE),
) |>
print()

# using lazy pipe
# create a function by composing partial expressions with %=>% operator
compute_mass_stats =
group_by(species, island, .add = TRUE) %=>%
summarize(
mean_body_mass = mean(body_mass_g, na.rm = TRUE),
sd_body_mass = sd(body_mass_g, na.rm = TRUE)
)

# then pass data
compute_mass_stats(penguins)

slide from a presentation that reads "Syntax don't solve your problems"

Screenshot of text from the linked blog post. The text reads:

but the craft

Do you like fine Japanese woodworking? All hand tools and sashimono joinery? Me too. Do it on your own time.

† (I’m a piker compared to my woodworking friends)

I have a basic wood shop in my basement †. I could get a lot of satisfaction from building a table. And, if that table is a workbench or a grill table, sure, I’ll build it. But if I need, like, a table? For people to sit at? In my office? I buy a fucking table.

Professional software developers are in the business of solving practical problems for people with code. We are not, in our day jobs, artisans. Steve Jobs was wrong: we do not need to carve the unseen feet in the sculpture. Nobody cares if the logic board traces are pleasingly routed. If anything we build endures, it won’t be because the codebase was beautiful.

Besides, that’s not really what happens. If you’re taking time carefully golfing functions down into graceful, fluent, minimal functional expressions, alarm bells should ring. You’re yak-shaving. The real work has depleted your focus. You’re not building: you’re self-soothing.

screen shot from the blog post. Text reads:

I am being silly, but I have this irrational beef with Python. Python has a lot of trivial syntax sugar for operations that could simply be functions. I like functions because you can do things with functions: composing, mapping, reducing, currying. You can’t do much with syntax sugar. In Python, all the sugar is parsed away to C code before any operations are actually executed against your data. So the syntax sugar in Python is convenient, but programmatically it is kind of useless.

A gif showing a tetronimo piece going out of bounds to the left of the game board, and when the piece is sent to the bottom of the board, some of it appears on both sides of the board.

A Git diff showing the addition of `import typer; typer.run(main)`

a computer window showing a tetris-like game. pieces are red, green, blue, yellow, and red. Some pieces have already been played.

Picture of a keyboard. The left GUI / Cmd key is circled

a plot of marginal and effective tax rate as income goes from $0 to $1mil. the effective tax rate is always below the marginal tax rate and is much smoother than the marginal rate

$screenshot of a terminal command and output: uv run tmd parse --archive ../twitter-archive/twits -o tweets.json && head -20 tweets.json [ { "tweet": { "edit_info": { "initial": { "editTweetIds": [ "1855701514406309953" ], "editableUntil": "2024-11-10T20:58:12.000Z", "editsRemaining": "5", "isEditEligible": true } }, "retweeted": false, "source": "<a href=\"https://mobile.twitter.com\" rel=\"nofollow\">Twitter Web App</a>", "entities": { "hashtags": [], "symbols": [], "user_mentions": [], "urls": []$

photo of apartment living room, v60 coffee making station on the counter in the foreground

$""" No-Significant-Whitespace Python. Not even function defs! """ import itertools from pathlib import Path from typing import Any, List, Callable as Function parse_words: Function[str, List[str]] = lambda chars: \ [s for s in chars.split(" ") if s != ""] parse_int_sequence: Function[str, List[int]] = lambda chars: \ [int(word) for word in parse_words(chars)] diff_series: Function[List[int], List[int]] = lambda series: \ [a - b for a, b in itertools.pairwise(series)] all_same_sign: Function[List[int], bool] = lambda seq: \ all(x < 0 for x in seq) or all(x > 0 for x in seq) # haters weep that we find a use for this yet again... juxt: Function[List[Function], Function[Any, List[Any]]] = lambda fns: \ lambda *args, **kws: [fn(*args, **kws) for fn in fns] good_seq_checks: Function[List[int], List[bool]] = lambda seq: \ juxt([all_same_sign, lambda lst: all(1 <= abs(x) <= 3 for x in lst)])(diff_series(seq)) is_safe_sequence: Function[List[int], bool] = lambda seq: \ all(good_seq_checks(seq)) part_one: Function[Path, int] = lambda filepath: \ sum(is_safe_sequence(parse_int_sequence(seq)) for seq in open(filepath).read().splitlines()) if __name__ == "__main__": pt2_data = Path("data/2024/02") test_file = pt2_data / "test.txt" final_file = pt2_data / "final.txt" assert part_one(test_file) == 2 print(f"{part_one(final_file)=}")$

Screen grab of the Python code that created this post.

$Rendered web page, dark screen, monospace text, orange accent color, very retro terminal looking. Text is rendered latex from following code: Dollars $ a = x $ and parens $b + c$ Double dollar: $$ a = x $$ Square bracket: \[ a + 1 \] Escaping dollars between \\$100 and \\$200.$