Justin Garcia

@purefunctor.me

675 Followers 475 Following

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

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

cargo clean

Removed 739246 files, 90.7GiB total

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

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."

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

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

A demo of progressive disclosure patterns for compiler testing in the purescript-analyzer codebase, showing the Amp coding agent discover instructions from the testing scripts in the codebase.

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

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

$#[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, } }$

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.

$// 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?)$

btop screenshot showing 1.03 GiB memory usage for purescript-analyzer

$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); } } }$

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

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

// 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_

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

(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

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

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

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

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

$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)); }$

λ ~/pf/purescript-analyzer/ main* hyperfine -N --prepare "sync" --warmup 100 "./target/release/compat"
Benchmark 1: ./target/release/compat
Time (mean ± σ): 1.3 ms ± 0.1 ms [User: 0.6 ms, System: 0.4 ms]
Range (min … max): 1.2 ms … 1.5 ms 76 runs

$queryFns ∷ ∀ r. { | QueryFns r } queryFns = { parsedFile: absurd , surfaceFull: surfaceFullImpl , surface: surfaceImpl , interface: interfaceImpl , scopeGraph: scopeGraphImpl , diagnostics: diagnosticsImpl } surfaceFullImpl ∷ ∀ r. QueryFn r FileId SurfaceLower.Result surfaceFullImpl engine id = do parsedFile ← inputGet @"parsedFile" engine id case parsedFile of ParsedTotal m → SurfaceLower.lowerModule m ParsedPartial m _ → SurfaceLower.lowerModule m surfaceImpl ∷ ∀ r. QueryFn r FileId Module surfaceImpl engine id = queryGet @"surfaceFull" engine id <#> _.surface interfaceImpl ∷ ∀ r. QueryFn r FileId InterfaceCollect.Result interfaceImpl engine id = do surface ← queryGet @"surface" engine id InterfaceCollect.collectInterface surface scopeGraphImpl ∷ ∀ r. QueryFn r FileId ScopeCollect.Result scopeGraphImpl engine id = do surface ← queryGet @"surface" engine id { interface } ← queryGet @"interface" engine id ScopeCollect.collectModule surface interface diagnosticsImpl ∷ ∀ r. QueryFn r FileId (Set Diagnostic) diagnosticsImpl engine id = do parsedFile ← inputGet @"parsedFile" engine id surfaceResult ← queryGet @"surfaceFull" engine id interfaceResult ← queryGet @"interface" engine id pure $ DiagnosticsCollate.collateDiagnostics parsedFile surfaceResult interfaceResult$

5.2.2 Verifying Step Traces from https://simon.peytonjones.org/assets/pdfs/build-systems-jfp.pdf

Build Systems a la Carte presentation slide by Simon Peyton Jones describing how the Task type's polymorphism can be used to extract static dependencies in a single line.

$let (name_token, declaration, item_fn, make_fn) = match declaration { TypeDeclaration::Class(d) => ( d.class_head().and_then(|h| h.name_token()), cst::Declaration::ClassDeclaration(d), TypeItem::class_group as TypeItemGroupFn, TypeItem::class_item as MakeTypeItemFn, ), TypeDeclaration::Data(e) => ( e.name_token(), cst::Declaration::DataEquation(e), TypeItem::data_group as TypeItemGroupFn, TypeItem::data_item as MakeTypeItemFn, ), TypeDeclaration::Newtype(e) => ( e.name_token(), cst::Declaration::NewtypeEquation(e), TypeItem::newtype_group as TypeItemGroupFn, TypeItem::newtype_item as MakeTypeItemFn, ), TypeDeclaration::Synonym(e) => ( e.name_token(), cst::Declaration::TypeSynonymEquation(e), TypeItem::synonym_group as TypeItemGroupFn, TypeItem::synonym_item as MakeTypeItemFn, ), };$

Shipped Items: Keychron V10 Max with Gateron Jupiter Switches

create_ast_enum!(
Expression
| ExpressionTyped
| ExpressionOperatorChain
| ExpressionInfixChain
| ExpressionTick
| ExpressionNegate
| ExpressionApplicationChain
| ExpressionTypeArgument
| ExpressionTermArgument
| ExpressionIfThenElse
| ExpressionLetIn
| ExpressionLambda
| ExpressionCaseOf
| ExpressionDo
| ExpressionAdo
| ExpressionConstructor
| ExpressionVariable
| ExpressionOperatorName
| ExpressionSection
| ExpressionHole
| ExpressionString
| ExpressionChar
| ExpressionTrue
| ExpressionFalse
| ExpressionInteger
| ExpressionNumber
| ExpressionArray
| ExpressionRecord
| ExpressionParenthesized
| ExpressionRecordAccess
| ExpressionRecordUpdate
);

A screenshot of the PureScript Analyzer Lossless CST demo

Ghostty showing logs of files being parsed—zero files remaining to be fixed.

$test_each_file! { in "./crates/parsing/tests/parser" as lossless => |content: &str| { let lexed = lexing::lex(content); let tokens = lexing::layout(&lexed); let (node, _) = parsing::parse(&lexed, &tokens); assert_eq!(node.to_string(), content); }} test_each_file! { in "./crates/parsing/tests/parser" as stability => |content: &str| { let lexed = lexing::lex(content); for index in 0..lexed.kinds().len() - 1 { let partial = lexed.text_in_range(0..index + 1); let lexed = lexing::lex(partial); let tokens = lexing::layout(&lexed); let (node, _) = parsing::parse(&lexed, &tokens); assert_eq!(node.to_string(), partial); } }}$

let c = p.checkpoint();

let bind = c.branch(p, do_statement_bind);
let discard = c.branch(p, do_statement_discard);

p.decide([bind, discard]);

By default, constructors are qualified by the types that they create.

justZero : List Int
justZero = List:Cons 0 List:Nil

However, the use declaration can be used to expose constructors without explicit qualification.

use List

justZero : List Int
justZero = Cons 0 Nil

justZero : List Int
justZero =
let
use List
in
Cons 0 Nil

$fn expression_5(p: &mut Parser) { let mut m = p.start(); if p.at(SyntaxKind::IF) { expression_if_then_else(p, m); } else if p.at(SyntaxKind::LET) { expression_let(p, m); } else if p.at(SyntaxKind::BACKSLASH) { expression_lambda(p, m); } else if p.at(SyntaxKind::CASE) { expression_case(p, m); } else if p.at(SyntaxKind::DO) { expression_do(p, m); } else if p.at(SyntaxKind::ADO) { expression_ado(p, m); } else if p.at(SyntaxKind::PREFIX) && p.at_next(SyntaxKind::DO) { expression_do(p, m); } else if p.at(SyntaxKind::PREFIX) && p.at_next(SyntaxKind::ADO) { expression_ado(p, m); } else if p.at_in(EXPRESSION_ATOM_START) { expression_6(p); m.cancel(p); } else { m.cancel(p); } } fn expression_if_then_else(p: &mut Parser, mut m: NodeMarker) { p.expect(SyntaxKind::IF); expression(p); p.expect(SyntaxKind::THEN); expression(p); p.expect(SyntaxKind::ELSE); expression(p); m.end(p, SyntaxKind::ExpressionIfThenElse); } fn expression_let(p: &mut Parser, mut m: NodeMarker) { m.end(p, SyntaxKind::ExpressionLetIn); } fn expression_lambda(p: &mut Parser, mut m: NodeMarker) { m.end(p, SyntaxKind::ExpressionLambda); } fn expression_case(p: &mut Parser, mut m: NodeMarker) { m.end(p, SyntaxKind::ExpressionCaseOf); } fn expression_do(p: &mut Parser, mut m: NodeMarker) { m.end(p, SyntaxKind::ExpressionDo); } fn expression_ado(p: &mut Parser, mut m: NodeMarker) { m.end(p, SyntaxKind::ExpressionAdo); } fn expression_6(p: &mut Parser) { expression_7(p); }$

parser_tests!(
comment_pre_post => include_str!("parser/CommentPrePost.purs"),
module_export => include_str!("parser/ModuleExport.purs"),
module_export_class => include_str!("parser/ModuleExportClass.purs"),
module_export_class_error_end => include_str!("parser/ModuleExportClassErrorEnd.purs"),
module_export_comma_error => include_str!("parser/ModuleExportCommaError.purs"),
module_export_data => include_str!("parser/ModuleExportData.purs"),
module_export_data_comma_error => include_str!("parser/ModuleExportDataCommaError.purs"),
module_export_data_item_after_double_period => include_str!("parser/ModuleExportDataItemAfterDoublePeriod.purs"),
module_export_data_item_before_double_period => include_str!("parser/ModuleExportDataItemBeforeDoublePeriod.purs"),
module_export_empty => include_str!("parser/ModuleExportEmpty.purs"),
module_export_invalid => include_str!("parser/ModuleExportInvalid.purs"),
module_export_type_operator => include_str!("parser/ModuleExportTypeOperator.purs"),
module_export_type_operator_error => include_str!("parser/ModuleExportTypeOperatorError.purs"),
module_export_type_operator_error_end => include_str!("parser/ModuleExportTypeOperatorErrorEnd.purs"),
module_header => include_str!("parser/ModuleHeader.purs"),
module_header_prefixed => include_str!("parser/ModuleHeaderPrefixed.purs"),
);

Warning from my service provider to not click links immediately followed by a spoofed phishing link.

$fn module_export_list(p: &mut Parser) { let mut marker = p.start(); 'list: { if p.at(SyntaxKind::LEFT_PARENTHESIS) { p.consume(); if p.at(SyntaxKind::RIGHT_PARENTHESIS) { p.error("Empty export list"); p.consume(); break 'list; } let mut after_item = false; while !p.at(SyntaxKind::RIGHT_PARENTHESIS) && !p.at_eof() { if p.at_in(EXPORT_ITEM_START) { module_export_item(p); after_item = true; continue; } if p.at(SyntaxKind::COMMA) { if p.at_next(SyntaxKind::RIGHT_PARENTHESIS) { p.error_recover("Trailing comma in export list"); continue; } if after_item { p.consume(); after_item = false; continue; } p.error_recover("Missing item in export list"); continue; } if p.at_in(EXPORT_LIST_RECOVERY) { break; } p.error_recover("Invalid token in export list"); after_item = true; } p.expect(SyntaxKind::RIGHT_PARENTHESIS); } } marker.end(p, SyntaxKind::ModuleExportList); }$

MacOS "your system has run run out of application memory" warning.

Firefox accumulated 54 GBs of memory usage overnight.

My tweet from 20 Jan 2022:

Why do I gravitate to languages that won't get me hired?

Arcaea Nhelv clear score at 9,942,339; previous score was 9,829,444

$fn block_comment(input: &mut Input<'_>) -> PResult<Lexed> { let Range { start, .. } = "{-".span().parse_next(input)?; let Range { end, .. } = loop { let content = take_until(0.., "-}").parse_next(input)?; let end = "-}".span().parse_next(input)?; if memmem::find_iter(content.as_bytes(), "{-").count() == 0 { break end; } }; Ok(Lexed::token(SyntaxKind::BLOCK_COMMENT, start..end)) }$

$Rust code: #[inline] fn take_block_comment(&mut self) { let position = self.position(); assert_eq!(self.take(), '{'); assert_eq!(self.take(), '-'); let mut level = 1; loop { match (self.first(), self.second()) { ('{', '-') => { level += 1; self.take(); self.take(); } ('-', '}') => { level -= 1; self.take(); self.take(); } _ => (), } if level == 0 { break; } self.take(); } self.lexed.push(SyntaxKind::BlockComment, position, None) }$

$Rust code: fn block_comment(input: &mut Stream<'_>) -> PResult<Token> { let mut builder = SmolStrBuilder::new(); let open = "{-".parse_next(input)?; builder.push_str(open); loop { let body = take_until(1.., "-}").parse_next(input)?; builder.push_str(body); let close = "-}".parse_next(input)?; builder.push_str(close); if memmem::find_iter(body.as_bytes(), "{-").count() == 0 { break; } } let kind = BLOCK_COMMENT; let text = builder.finish(); let position = input.state.write(&text); Ok((kind, text, position)) }$