5 ms·
Inverse Parentheses
- TeodorDyakov 10mo agoWhere do stars live? Thats what I wonder.
- tromp 10mo agoUsing Brave on MacOS, I cannot scroll the page to see the entire text. On Firefox, it scrolls fine.
- guessmyname 10mo agoSame in Safari. It has something to do with the :root { […] overflow: hidden scroll; container-type: size; […] } in the main CSS file: https://kellett.im/theme/main.css https://kellett.im/theme/main.css
- auggierose 10mo agoCannot scroll on Safari on macOS, either. What also doesn't work is making the font smaller / larger.
- TerraHertz 10mo agoSplendid. Someone found a way to break Browser Scrolling. (Firefox 115.16 for Win7) Well done.
- bananaflag 10mo ago> Have you ever noticed that lots of programming languages let you use parentheses to group operands, but none use them to ungroup them? Since this doesn't exist in practice, shouldn't the article author first explain what they mean by that?
- Smaug123 10mo agoThe examples at the end show that it's syntax for "parse such that this expression is not grouped". Essentially I guess this could be modelled as an operator `(_+_)` for every existing operator `_+_`, which has its binding precedence negated.
- pxeger1 10mo agoI don't understand
- deleted 10mo ago[deleted]
- carderne 10mo agoI was hoping the parentheses themselves would be flipped. Like this: > 1 + )2 * 3( (1 + 2) * 3
- dgoldstein0 10mo agoSame. That said if you try to use that with ordinary parentheses usage it would get ambiguous as soon as you nest them
- chrisweekly 10mo agoWait, no. It makes no sense to use the same characters! An "inverted" opening parens is visually identical to a "normal" closing parens. IMHO the entire proposition is inane.
- dgoldstein0 9mo agoExactly.
- AmbroseBierce 10mo agoI think surrounding the operand would make slightly more sense, as in 1 + 2 (*) 3 as if it's a "delayed form" of the operation that it represents.
- SyzygyRhythm 10mo agoIf you do both (use flipped parentheses around the operators), it makes even more sense, and makes the parsing trivial to boot: just surround the entire expression with parentheses and parse normally. For instance: 1 + 2 )( 3 Becomes (1 + 2 )( 3) Which is actually just what the author wants. You might even want multiple, or an arbitrary numbers of external parentheses. Say we want to give the divide the least precedence, the multiply the middle, and the add the most. We could do that like: 1 + 2 )/( 3 ))(( 4 Surround it with two sets of parens and you have: ((1 + 2 )/( 3 ))(( 4)) I haven't just proved to myself this always does what you expect, though...
- louthy 10mo agoI'm all for terseness in blog writing, but I think the author forgot to add the content. I know nothing more than I did when I opened it.
- brabel 10mo agoAnd yet, this is the top entry on HN right now?! How does that happen??
- throwaway150 10mo agoI read the article twice and still doesn't make sense. I tried to make sense but no matter how I slice and dice the article, the "inverse parentheses" idea seems inconsistent or ill defined. Two comments here which explain the ill-definedness of it: https://news.ycombinator.com/item?id=46352560 https://news.ycombinator.com/item?id=46352560 https://news.ycombinator.com/item?id=46352697 https://news.ycombinator.com/item?id=46352697
- Philpax 10mo agoEngagement from people trying to figure it out :-)
- xeonmc 10mo agoThe blue/gold dress of HN nerd sniping
- HansP958 10mo agoThe concept of "inverse parentheses" that unbundle operators is brilliant! The tokenizer hack (friendliness score by parenthesis depth, inspired by Python INDENT/DEDENT) + precedence climbing for infinite levels is elegant – parsing solved without convoluted recursive grammar. kellett I love the twist: reversing the friendly levels gives you a classic parser, and it opens up crazy experiments like whitespace weakening. Have you tested it on non-arithmetic ops (logical/bitwise) or more complex expressions like ((()))?
- istjohn 10mo agoIt's not just brilliant, it's earth-shattering.
- codegladiator 10mo agollm generated comment
- NetMageSCW 10mo agoI am sure your comment is almost always wrong whenever you use it.
- Philpax 10mo agoEchoing the sentiment that I'm not really sure what I'm meant to be looking at here. A motivating example at the start would have helped, I think.
- ChanderG 10mo agoOpened this excitedly, thinking I was going to get something related to S-expressions/Lisp, was disappointed...
- qsort 10mo agoAm I stupid if I don't get it? What is the intended end state? What does "ungroup operands" mean?
- jojobas 10mo agoI'm not sure I'm following but I think what he means is that if normal parenthesis around an addition mean this addition must precede multiplication, these anti-parenthesis around a multiplication have to make addition take place before it.
- suspended_state 10mo agoI think ungrouping make sense if you consider reverse parentheses as a syntactic construct added to the language, and not replacing the existing parentheses. For instance, using "] e [" as the notation for reverse parentheses around expression e, the second line showing reverse parenthese simplification, third line showing the grouping after parsing, and the fourth line using postfix notation: A + B * (C + D) * (E + F) => A + B * (C + D) * (E + F) => (A + (B * (C + D) * (E + F))) => A B C D + E F + * * + A + ] B * (C + D) [ * (E + F) => A + B * C + D * (E + F) => ((A + (B * C)) + (D * (E + F))) => A B C * + D E F * + + So what ungrouping would mean is to undo the grouping done by regular parentheses. However, this is not what is proposed later in the article. Possibilities include reversing the priority inside the reverse parentheses, or lowering the priority wrt the rest of the expression.
- suspended_state 10mo agoI stumbled on this: https://lobste.rs/s/qoqfwz/inverse_parentheses#c_n5z77w https://lobste.rs/s/qoqfwz/inverse_parentheses#c_n5z77w which should provide the answer.
- ofalkaed 10mo agoParenthesis used to decrease precedence? Everything outside of the parenthesis will be done before what is in the parenthesis?
- TrianguloY 10mo agoBased on this comment (https://news.ycombinator.com/item?id=46352389 https://news.ycombinator.com/item?id=46352389), I think I understood the missing first paragraph: If you have the expression 1+2*3 you have three elements with two operands. You need to choose a rule to pick one of them first. In mathematics, the rule is "*/ then +-" and then from left to right. This means that usually first you do 2*3, then 1+. But what if you do want to make 1+2 first? There is another alternative, parenthesis. Those mean "do the thing inside first" so (1+2)*3 changes the precedence and now you do 1+2 first, then *3 The post is asking: with parenthesis you can increase the precedence of operations. What if you could decrease it? Let's use «» as another operand (the blog uses parenthesis, but that makes it really confusing) this operand means "do the thing inside last". So the expression 1+«2*3» means "do 1+ first, then 2*3. The issue is...this doesn't make sense, what the blog is really saying is to reduce the precedence of operators. Think the expression 1+2«*»3 or 1+2(*)3 and now the rule is "the parenthesized operators have one precedence less" so 1+2(*)3=(1+2)*3
- integricho 10mo agoThanks, this makes more sense, the blog post was written in a really confusing way.
- yccs27 10mo agoThanks, writing it as 1+2(*)3 made it click for me. Reminds me of the '$' operator in Haskell - it lowers the precedence of function application, basically being an opening parenthesis that's implicitly closed at the end of the line.
- sebtron 10mo agoThis seems to be the best guess so far. But then I am wondering, how is a (*) b + c Parsed then? The precedence of '* is bumped down, but does that mean it has now strictly lower precedence of '+', or the same? In the first case the operation is parsed as a * (b + c) In the second case, the "left to right" rule takes over and we get (a * b) + c And what happens when there are more than 2 priority groups Taking C has an example, we have that '' has higher precedence than '+' which has higher precedence than '<<' [1]. So a + b * c << d Means (a + (b * c)) << d Now I could use the "decrease precedence" operator you proposed (possibly proposed by the author?) and write a + b (*) c << d Which then bumps down the precedence of '' to... One level lower? Which means the same level of '+', or a level lower, i.e. a new precedence level between '+' and '<<'? Or maybe this operator should end up at the bottom of the precedence rank, i.e. lower than ','? The more I think about this, the less sense it makes... [1] https://en.cppreference.com/w/c/language/operator_precedence.html https://en.cppreference.com/w/c/language/operator_precedence...
- cubefox 10mo agoSlightly unrelated: Instead of ordinary brackets, one can also use the dot notation. I think it was used in Principia Mathematica or slightly later: (A (B (C D))) would be A . B : C .: D Essentially, the more dots you add, the stronger the grouping operator is binding. The precedence increases with the number of dots. However, this is only a replacement for ordinary parentheses, not for these "reverse" ones discussed here. Maybe for reverse, one could use groups of little circles instead of dots: °, °°, °°°, etc.
- agumonkey 10mo agocould this be the origin of lisp and ML family list notation ?
- agalunar 10mo agoI believe Peano dot notation works the other way ’round; A . B : C :. D would be, as I understand it, equivalent to: ((A B) C) D The “general principle” is that a larger number of dots indicates a larger subformula.¹ What if you need to nest parentheses? Then you use more dots. A double dot (:) is like a single dot, but stronger. For example, we write ((1 + 2) × 3) + 4 as 1 + 2 . × 3 : + 4, and the double dot isolates the entire 1 + 2 . × 3 expression into a single sub-formula to which the + 4 applies.² A dot can be thought of as a pair of parentheses, “) (”, with implicit parentheses at the beginning and end as needed. In general the “direction” rule for interpreting a formula ‘A.B’ will be to first indicate that the center dot “works both backwards and forwards” to give first ‘A).(B’, and then the opening and closing parentheses are added to yield ‘(A).(B)’. The extra set of pairs of parentheses is then reduced to the formula (A.B).³ So perhaps one way of thinking about it is that more dots indicates more separation. ¹ https://plato.stanford.edu/entries/pm-notation/dots.html https://plato.stanford.edu/entries/pm-notation/dots.html ² https://blog.plover.com/math/PM.html https://blog.plover.com/math/PM.html ³ https://plato.stanford.edu/entries/pm-notation/dots.html https://plato.stanford.edu/entries/pm-notation/dots.html See also https://plato.stanford.edu/entries/pm-notation/index.html https://plato.stanford.edu/entries/pm-notation/index.html and https://muse.jhu.edu/article/904086 https://muse.jhu.edu/article/904086.
- 10mo ago
- wvbdmp 10mo agoRegarding the first two footnotes, I’m pretty sure that originally the singular form “parenthesis” just refers to the aside inserted (by use of brackets, like this) into a sentence. Because it sounds like a plural and because of the expression “in parenthesis”, people probably mistakenly applied the word to the pair of symbols, and when that became common, started using the real plural “parentheses”. This has staying power because it’s fancy and “brackets” is way overloaded, but historically it’s probably just wrong and especially nonsensical in math and programming, where we don’t use them to insert little sidenotes.
- randyrand 10mo agoThe core idea: normally, parentheses strengthen grouping: 1 + (2 * 3) forces 2 * 3 to happen first. Without them, operator precedence decides. The post asks a deliberately strange question: What if parentheses did the opposite — instead of grouping things tighter, they made them bind less tightly?
- Nevermark 10mo agoI am in the middle of developing a parser for a new language with original representation vs. syntax issues to resolve. Clearly, this was the worst possible time for me to come across this brain damaging essay. I really can’t afford it! My mathematical heart can’t help taking symmetrical precedence control seriously. But my gut is experiencing an unpleasant form of vertigo.
- cousin_it 10mo agoIs it the same as flipping every parenthesis to the other side of the number it's adjacent to, and then adding enough parentheses at the start and end? For example, (1 + 2) * (3 + 4) becomes 1) + (2 * 3) + (4 and then we add the missing parentheses and it becomes (1) + (2 * 3) + (4) which seems to achieve a similar goal and is pretty unambiguous.
- Juliate 10mo agoHa! I was expecting/wondering something about the semantics of )( parenthesis (which I have no idea what it could be, but... why not?)
- deleted 10mo ago[deleted]
- Lerc 10mo agoI think reading this let me experience the feeling a Bene Gesserit has when they hear about a preborn.
- 0_gravitas 10mo agoWorking with lisp quickly made me realize how over-rated operator precedence (or even the concept of "operators") is. All such effort and early grade-school hours spent on this arbitrary short-hand instead of treating the operations themselves as functions and embracing the divine order of (more) parens.
- NetMageSCW 10mo agoDo you really like Lisp?
- 0_gravitas 10mo agoDisclaimer: I used the /royal/ LISP--as in the 'lisp family'- my introduction, and language of choice, has been Clojure (who's qualification as a Lisp is technically contended by certain fundamentalists), but it is still quite paren-based either-way. And I do, I bounced off it the first time long ago, and really took to it the second go around, its been my daily driver at home and work for some years now- it brings me great joy.
- tonnydourado 10mo agoThe footnotes are top-tier ADHD. Particularly loved the footnote on a footnote, 10/10.
- munchler 10mo agoPrompt: Suggest a topic for a short blog post that will nerd-snipe as many readers as possible while making no actual sense at all. System: How about “Inverse Parentheses”? We can write the entire article without ever defining what it means. Nerds will be unable to resist.
- teo_zero 10mo agoThe real question is, why does Python even have parentheses? If semantic indent is superior to braces, it ought to beat parentheses, too. The following should yield 14: a = 2 * 3 + 4
- kazinator 10mo agoAlso, don't forget that python has; list = [ 1,2,3, [ 4, 5 ], 6 ] Without this Python would basically have to be Yaml-ish Lisp: = a * 2 + 3 4 Let's drop the leading Yaml dashes needed to make ordered list elements. So we have an = node (assignment) which takes an a destination, and a * expression as the source operand. *'s operands are 2 and a + node, whose operands are 3 and 4.
- calmbonsai 10mo agoThe singular for parenthesis is paren.
- kazinator 10mo agoI've played with operator precedence parsing earlier this year to produce an infix implementation for TXR Lisp. Documentation entry point: https://www.nongnu.org/txr/txr-manpage.html#N-BEB6083E https://www.nongnu.org/txr/txr-manpage.html#N-BEB6083E I may have invented something new, which I called "Precedence Demotion". I did some research regarding prior art for this exact thing but didn't find it. https://www.nongnu.org/txr/txr-manpage.html#N-89023B87 https://www.nongnu.org/txr/txr-manpage.html#N-89023B87 LOL, I see I have a bug in the quadratic-roots example (not related to the above). The example has correct results for the given inputs because a is 1. It's ironic: you add infix to Lisp and, wham, you make a bugeroo because of infix that would never happen in prefix, right in the documentation. Like a poetic justice punishment.