Will Crichton

The language's semantics are carefully designed to enable the authoring of both web elements (ie React objects that can be interactive) and strings (eg TeX, Penrose, to pass to an external component).

Scribble-inspired notation can be used at the top-level, but also nested inside a Javascript expression. Imagine a template string, but on steroids.

Too many brands on Twitter, not enough static analysis toolshttps://twitter.com/creduce/status/1470099794609655808 …

trait FooExt {fn bar(&self) -> Vec<u32>} => trait FooExt { type Bar<'a>: Iterator<Item=u32> where Self: 'a; fn bar(&self) -> Self::Bar<'_>; } impl FooExt for Foo { type Bar<'a> where Self: 'a = impl Iterator<Item=u32>; fn bar(&self) -> Self::Bar<'_> { ... } }

The lack of `impl Trait` in Rust trait definitions is a frustrating limitation. Eg I want my trait method to return an iterator instead of a vector, but don't want to specify the iterator type. You can overcome it, but it's gross and requires two nightly features:

Using fold instead of for-loop is annoying. But one benefit: flip a character to unroll the state of the fold. q) ((); 0) check/ "()({)" "({" 3 q) ((); 0) check\ "()({)" ,"(" 0 "" 0 ,"(" 0 "({" 0 "({" 3

Q's combinators are interesting. Especially overloading on arity: f' = map f x f' y = map f (zip x y) x f/: y = map (f x) y x f\: y = map (λ x. f x y) x f/ (unary) = fix λ g. λ y. if f y = y then y else g (f y) f/ (binary) = reduce f x f/ y = fold f x y x f\ y = scan f x y

Some cool properties: * A node's ancestors = backward slice (and descendants = forward). * Weakly connected components are independent computations, so they could be e.g. parallelized or trivially factored. * Any topological sort is a valid reordering of the program.

Graph theoreticians: let G be a 𝘥𝘦𝘤𝘪𝘥𝘶𝘰𝘶𝘴 𝘵𝘳𝘦𝘦 (maximum out-degree of 1 in the winter)

Mild take: if you ever feel like learning an esoteric language with a dizzying array of symbols and vocabulary, Q is probably a better choice than Haskell.

Also "underexplored" isn't quite right. The web is rife with templating languages, which are string-first PLs. But they all suck, except for JSX.

Scribble is by far the best example of this design, but I've found it hard to directly translate its concepts into JS / React. Eg sometimes you want to generate a string (say to pass to KaTeX or Penrose), sometimes you want to generate a React element.

Requirements: * No quotes or escapes -- strings are the default, not the exception. * Allow transition between string and code dialects with as few characters as possible, and with arbitrary nesting. * Should be easy to define non-string data structures: lists, classes, lambdas

String-first programming languages seem to be a really interesting and underexplored design space. I want something halfway between JSX and Scribble, but not MDX.

Did you know that there's a "copy" event that can disable copying, even from selected text? Did you know that getEventListeners ONLY WORKS WHEN RUN IN THE DEV TOOLS???