Justin Garcia

@purefunctor

I work on full-stack web and code intelligence, 🇵🇭 he/him

477 Siguiendo673 Seguidores236 Publicaciones

YouTube Bluesky

¿Es tu perfil?Reclámalo y purefunctor.dirty.social es tuyo.Reclamar perfil

Justin Garcia@purefunctor· Jun 18

I added a rotary knob to configure the oklch hue on my website

Justin Garcia@purefunctor· May 28

I wonder if my project is being used for evals somewhere

GitHub insights graphs:

Clones in the last 14 days peaks at 2318
Unique cloners in the last 14 days peaks at 161
Total views in last 14 days peaks at 126
Unique visitors in last 14 days peaks at 6

Justin Garcia@purefunctor· May 25

I fear for my SSD health

cargo clean

Removed 739246 files, 90.7GiB total

Justin Garcia@purefunctor· May 23

used Amp's Rush 2.0 to write a super basic jj/git status for my starship setup

Justin Garcia@purefunctor· May 21

1 year of @kagi.com 💛

Justin Garcia@purefunctor· May 14

delta / difft

Justin Garcia@purefunctor· May 14

oh jj

cargo clippy --fix, followed by jj absorb distributing the fixes into the correct revisions.

Justin Garcia@purefunctor· Feb 20

that's a first

Amp Code transcript

No worries — restart and it should pick up the new permission rule. Try giving me a task after that and we'll see it in action!
let's do it again 2 + 2
$ say -v "Bubbles" "Two plus two is four. Mafs. Quick mafs. The calculator trembles before my power."
two plus two is four minus one that's...
3, quick maths! 🎤
$ say -v "Fred" "Three. Quick maths. Everyday mans on the block. Smoke trees."

Justin Garcia@purefunctor· Feb 17

you're telling me you can just do that in jj?

Terminal screenshot showing `jj log --limit 5`, the latest 5 commits; then `jj sign` which trivially adds a signature for all of them

Justin Garcia@purefunctor· Jan 29

"However, we wish to stay close to programming practice and define patterns as follows" moscova.inria.fr/~maranget/pa...

Excerpt from http://moscova.inria.fr/~maranget/papers/warn/warn003.html

Patterns are used to discriminate amongst values. More precisely a pattern describes a set of values with a common prefix. That is, patterns are terms with variables and a given pattern p describes its instances σ(p) where σ ranges over substitutions. However, we wish to stay close to programming practice and define patterns as follows:

p ::= Patterns
_ wildcard
c(p1,p2, … ,pa) constructed pattern a ≥ 0
(p1 ∣ p2) or-pattern

Justin Garcia@purefunctor· Jan 25

my 2 days of GPT-5.2 xhigh so far

Justin Garcia@purefunctor· Jan 21

Testing out progressive disclosure patterns for compiler testing tools with @ampcode.bsky.social

Justin Garcia@purefunctor· Jan 19

purescript-analyzer's playground now supports loading PureScript packages from the package set, check it out: purefunctor.github.io/purescript-a...

a screenshot of the purescript-analyzer playground, showing an example program and the type checker output

Justin Garcia@purefunctor· Jan 16

what do we have here 👀

"Internal Opus 4.5" by "Stealth" in the OpenCode dashboard.

Justin Garcia@purefunctor· Jul 11

Justin Garcia@purefunctor· May 18

I love when abstractions fall right into place

$#[derive(Debug, PartialEq, Eq)] pub enum Thing { Annotation(cst::Annotation), Expression(cst::Expression), Nothing, } pub fn thing_at_position(content: &str, parsed: ParsedModule, position: Position) -> Thing { let Some(offset) = position_to_offset(content, position) else { return Thing::Nothing; }; let node = parsed.syntax_node(); let token = node.token_at_offset(offset); match token { TokenAtOffset::None => Thing::Nothing, TokenAtOffset::Single(token) => thing_from_single(token), TokenAtOffset::Between(left, right) => thing_from_between(left, right), } } fn thing_from_single(token: SyntaxToken) -> Thing { token.parent_ancestors().find_map(thing_classify_node).unwrap_or(Thing::Nothing) } fn thing_classify_node(node: SyntaxNode) -> Option<Thing> { let kind = node.kind(); if cst::Annotation::can_cast(kind) { cst::Annotation::cast(node).map(Thing::Annotation) } else if cst::Expression::can_cast(kind) { cst::Expression::cast(node).map(Thing::Expression) } else { None } } fn thing_from_between(left: SyntaxToken, right: SyntaxToken) -> Thing { let left = left.parent_ancestors().find_map(thing_classify_node).unwrap_or(Thing::Nothing); let right = right.parent_ancestors().find_map(thing_classify_node).unwrap_or(Thing::Nothing); match (&left, &right) { // If left/right share an ancestor (_, _) if left == right => left, (_, Thing::Nothing) => left, (Thing::Nothing, _) => right, // Otherwise, lean towards the right (_, _) => right, } }$

Justin Garcia@purefunctor· May 17

Now I gotta figure out how to make the build system parallel

Benchmark results for single core and multi core parsing the entire package set in the purescript-analyzer. 637ms on a single core, 108ms on 12 cores.

Justin Garcia@purefunctor· May 16

TIL that Option<NonZero<u32>> has the same size as NonZero<u32> and I'm wondering if it's a worthwhile optimisation to make for flattened ASTs? At 1 billion nodes yeah it'll save 12 GB but at a million 12 MB doesn't matter as much for modern hardware.

$// size = 28 bytes pub enum F { F1(Option<u32>, Option<u32>, Option<u32>), F2(Option<u32>, Option<u32>, Option<u32>), } // size = 16 bytes pub enum G { G1(Option<NonZero<u32>>, Option<NonZero<u32>>, Option<NonZero<u32>>), G2(Option<NonZero<u32>>, Option<NonZero<u32>>, Option<NonZero<u32>>), } // 28 * 1_000_000 = 28_000_000 bytes // 16 * 1_000_000 = 16_000_000 bytes // // 12_000_000 bytes -> 12 MB (does it matter?)$

Justin Garcia@purefunctor· May 15

The purescript-analyzer currently hovers around 1.0~1.3 GiB of memory usage for 871k (!!!) lines of PureScript. A good chunk of the memory being allocated comes from the AST, specifically the mechanism it currently uses for flattening the representation.

btop screenshot showing 1.03 GiB memory usage for purescript-analyzer

Justin Garcia@purefunctor· Apr 2

been a hot minute since I cooked this good

$fn explicit_module_exports( external: &mut impl External, state: &mut State, file: FileId, index: &Index, including_self: bool, ) { if including_self { implicit_module_exports(state, file, index); } for (name, id) in index.iter_term_nominal() { if index.is_term_exported(id) { state.add_term(name, file, id); } } for (name, id) in index.iter_type_nominal() { if index.is_type_exported(id) { state.add_type(name, file, id); } } for (_, items) in index.iter_import_items() { if !items.exported { continue; } let Some(name) = &items.name else { continue; }; let import = external.file_id(name); let exports = external.exports(import); for (name, (file, id)) in exports.terms.iter() { state.add_term(name, *file, *id); } for (name, (file, id)) in exports.types.iter() { state.add_type(name, *file, *id); } } }$

Justin Garcia@purefunctor· Apr 2

types when you write _help / ?help:

"Th-this is my hole!"
"It was made for me!"

Justin Garcia@purefunctor· Mar 11

erm

Your system has run out of application memory.

Discord 958.9 MB
Ghostty 141.25 GB
Pages 430.9 MBB
Slack 6.58 GB
Zen 8.80 GB
Finder 84.5 MB

Justin Garcia@purefunctor· Mar 2

Instance heads are annoying to lower

// TODO: Implement binding for Instance/InstanceBinder. Here are some cases to handle:
//
// instance Eq a
//
// instance TypeEq a a
//
// instance Ord a => Eq a
//
// We'll first encounter InstanceBinder when checking the instance head. If we were to
// bind the names naively, we'll encounter a case where a name would have already been
// bound (see TypeEq a a). We'll need to do some additional bookkeeping to manage
// implicit foralls.
//
// The first time we see an InstanceBinder, we push it into the scope, giving us a de
// Bruijn index. Subsequent usages of the InstanceBinder would simply return that de
// Bruijn index. Likewise, any usage of Instance would refer back to that type
// variable.
//
// Unlike explicitly-bound type variables, we have no identity to anchor to for
// implicit type variables. As such, we must create them on the fly when lowering types
// for instance heads. Although, we sort of do in a way? If we used an interner in the
// Constraint graph node, we could obtain an ID that's specific to that scope. That
// should be a sufficient anchor for de Bruijn indices _that is not_ SmolStr.
//
// Although, what if type variables didn't resolve to TypeVariableBindingId directly,
// but to the scope nodes that they were allocated in? Then, we'll need to perform the
// resolution _here_

Justin Garcia@purefunctor· Feb 20

Note to self: make sure the binary you're benchmarking bails if it doesn't find the files it's supposed to be using

Benchmark 1: ../target/release/compat
Time (mean ± σ): 695.4 ms ± 16.9 ms [User: 595.8 ms, System: 99.1 ms]
Range (min … max): 676.5 ms … 725.6 ms 10 runs

Justin Garcia@purefunctor· Feb 18

GHC... seems to generate them?

(SK2) All skolemisation (even without DeepSubsumption) builds just one implication
constraint for a nested forall like:
forall a. Eq a => forall b. Ord b => blah
The implication constraint will look like
forall a b. (Eq a, Ord b) => <constraints>
See the loop in GHC.Tc.Utils.Instantiate.topSkolemise.
and Note [Skolemisation en-bloc] in that module

Justin Garcia@purefunctor· Feb 18

I was just thinking about how skolemisation would fit in a constraint-generating type checker and I was wondering if it makes sense to use implication constraints for them.

Slide about implication constraints from Simon Peyton Jones' ZuriHac 2019 Keynote

https://drive.google.com/file/d/1NRkP0hz-0Yo49Rto70b2nUwxjPiGD9Ci/view

Justin Garcia@purefunctor· Feb 7

Why do banks make such terrible software? Like I get hanging on to archaic systems but stuff like this is inexcusable

An alert box that states "User is already logged-in"

Justin Garcia@purefunctor· Feb 5

What'd I say about tiny interactions again

Justin Garcia@purefunctor· Feb 3

one of the takes of all time

Rust is a programming language, but it's also a way for Marxists to subvert the establishment and overthrow institutions.

Justin Garcia@purefunctor· Feb 1

I love let-else

$fn lower_expr_value( state: &mut State, module: &cst::Module, index: &IndexingResult, group: &ValueGroupId, ) { let root = module.syntax(); let mut signature_id = None; 'signature: { let Some(signature) = group.signature else { break 'signature }; let Some(signature) = index.source_map.declaration_ptr(signature) else { break 'signature }; let Some(signature) = signature.try_to_node(root) else { break 'signature }; let cst::Declaration::ValueSignature(signature) = signature else { break 'signature }; let Some(signature) = signature.signature() else { break 'signature }; signature_id = Some(lower_type(state, &signature)); }; let capacity = group.equations.len(); let mut equation_id = Vec::with_capacity(capacity); for equation in &group.equations { let Some(equation) = index.source_map.declaration_ptr(*equation) else { continue }; let Some(equation) = equation.try_to_node(root) else { continue }; let cst::Declaration::ValueEquation(equation) = equation else { continue }; let Some(guarded) = equation.guarded_expression() else { continue }; let Some(where_expression) = guarded.where_expression() else { continue }; let Some(expression) = where_expression.expression() else { continue }; equation_id.push(lower_expression(state, &expression)); } dbg!((signature_id, equation_id)); }$