You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
The [WHATWG Fetch Standard][] contains several examples of using the DOM fetch
function, resolving its promises into values, then processing the values in
various ways. These examples may become more easily readable with smart pipelines.
I think the rules for infinite-lookahead would be:
If the first token is an ident or function, then:
If it's a dashed-ident (or function with a dashed-ident name), followed by any amount of whitespace, followed by a colon: it's a custom property.
If it's followed by any amount of whitespace and a colon, then look forward until you see either a semicolon or EOF (it's a property) or a {}-block (it's a rule).
Otherwise, it's a rule.
Otherwise, it's a rule.
This gives us infinite lookahead, with arbitrary mixing of properties and selectors, with only three compromises:
A FIRBOLG and a DWARF relax in beach chairs,
sipping pina coladas,
with halos above their head.
A skinny human man is building a sand castle at their feet.
DWARF: Gotta say, didn't expect to find myself enjoying this sorta afterlife.
We've been deadlocked for a while on the pipeline operator proposal, for a few reasons.
Partially it's just low implementor interest, as this is fundamentally just syntactic sugar,
but also because there are three competing proposals
and the proponents of each haven't been convinced by the others yet.
In this essay I hope to briefly outline the problem space,
summarize the three proposals,
and talk about what's gained/lost by each of them.
(Spoiler: they're all nearly identical; we're arguing over very small potatoes.)
On Sep 1 2022, Yulia and I had a VC to get past our misunderstandings/disagreements about pattern matching in a high-bandwidth fashion.
The high-level summary is that Yulia has three requests, all of which I think are reasonable. In order of complexity:
Allowing plain functions as custom matchers
Right now, custom matchers have to be done via an object with a Symbol.matcher key. The matcher function can be written as a plain boolean function now, but you still need that object wrapper, which is annoying as it prevents existing boolean functions from being easily used. Ideally you'd be able to write when(${someFunc}) and have it work exactly like when(${{[Symbol.matcher]: someFunc}}) does in today's spec.
The blocker for this is that we currently define Function.prototype[Symbol.matcher] to essentially do an instanceof check, so JS classes can be used by default: when(${MyClass}) will match if the matchable is an instance of MyClass or a subclass, wi
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Doubled letters in a word are yellow, tripled letters are green.
???? My first guess gave me a yellow T and green A, and I just made words putting those lettes where they needed to be and solved all the challenges. Surely it's not that simple???
(Edited to add: It's not that simple - the first letter in alphabetical order in your guess is green, the last is yellow. My first guess (and all subsequent) just happened to use A and T as the first/last letters.)
If you use the same letter in the same position as the immediately preceding guess, it's yellow. If a letter is used in the same position three guesses in a row, it's green. Good luck with the GGBGG pattern.