Inverse Parentheses
kellett.im62 points by mighty-fine 9 hours ago
62 points by mighty-fine 9 hours ago
Based on this comment (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
If we actually (as the title seems to imply) invert the parentheses, then for your example we get 1+2)*(3 .
Now all you need are the opening and closing parentheses at the start and end, and we're back to normal.
Thank you. I thought I was going crazy reading the article which doesn’t connect open and close parenthesis :: higher and lower precedence :: indent and outdent :: +1 and -1 and just flip it around to get the opposing polarity.
A real Wesley Crusher moment.
Yeah, that seems a much more robust formulation of the whole thing. Flip all parens and enclose the whole string in more parens.
that results in
(1+2)*(3)
(1+2)*3
I don't think that's even well-defined if you have arbitrary infix operators with arbitrary precedence and arbitrary associativity (think Haskell). If $, & and @ are operators in that order of precedence, all right-associatve. Using your notation, what is:
a & << b $ c >> @ d
((a & b) $ c) @ d
(a & b) $ (c @ d)
Clearly we need left-associative and right-associative inverse parentheses.
a & )b $ c) @ d would mean ((a & b) $ c) @ d.
a & (b $ c( @ d would mean a & (b $ (c @ d)).
Combining both, a & )b $ c( @ d would mean (a & b) $ (c @ d).
;)
This seems to be the best guess so far. But then I am wondering, how is
a (*) b + c
a * (b + c)
(a * b) + c
a + b * c << d
(a + (b * c)) << d
a + b (*) c << d
The more I think about this, the less sense it makes...
[1] https://en.cppreference.com/w/c/language/operator_precedence...
Thanks, this makes more sense, the blog post was written in a really confusing way.
Thanks indeed. Using a simple left-to-right evaluation is the most logical solution. You can reorder expressions to use less parentheses and make them easier to read. E.g.: Smalltalk :-). But this requires everyone un-learning their primary school maths of e.g. multiply-before-add, so it's not popular. Having hand-picked operator precedences complicates things further when you allow operator overloading and user defined operators. E.g. Swift has special keywords to specify precedence for these. Ick...
Thanks, 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.
> There is another alternative, parenthesis.
Gerald Jay "Jerry" Sussman from Scheme and SICP fame (and others) would tell you there's also the prefix notation (but ofc only infix makes TFA valid: prefix or postfix makes it mostly moot). "3 x 4 x 7 x 19" only looks natural to us because we've been taught that notation as toddlers (well, ok, as young kids).
But "x 3 4 7 19" is just as valid (Minksy and having to understand someting in five different ways or you don't understand it etc.).
P.S: also your comment stinks of AI to me.
I'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.
And yet, this is the top entry on HN right now?! How does that happen??
I 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:
Am I stupid if I don't get it? What is the intended end state? What does "ungroup operands" mean?
I 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.
I stumbled on this:
https://lobste.rs/s/qoqfwz/inverse_parentheses#c_n5z77w
which should provide the answer.
I'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.
> 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?
The 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.
I was hoping the parentheses themselves would be flipped. Like this:
> 1 + )2 * 3(
(1 + 2) * 3
I 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.
If 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...
Same.
That said if you try to use that with ordinary parentheses usage it would get ambiguous as soon as you nest them
Wait, 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.
Working 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.
Echoing 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.
The footnotes are top-tier ADHD. Particularly loved the footnote on a footnote, 10/10.
Regarding 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.
Is 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)
1) + (2 * 3) + (4
(1) + (2 * 3) + (4)
I 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.
I think reading this let me experience the feeling a Bene Gesserit has when they hear about a preborn.
The 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 ((()))?
Slightly 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)))
A . B : C .: D
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.
Parenthesis used to decrease precedence? Everything outside of the parenthesis will be done before what is in the parenthesis?
Where do stars live? Thats what I wonder.
Using Brave on MacOS, I cannot scroll the page to see the entire text. On Firefox, it scrolls fine.
Same in Safari. It has something to do with the
:root {
[…]
overflow: hidden scroll;
container-type: size;
[…]
}
Cannot scroll on Safari on macOS, either. What also doesn't work is making the font smaller / larger.
Splendid. Someone found a way to break Browser Scrolling. (Firefox 115.16 for Win7)
Well done.
I don't understand
Opened this excitedly, thinking I was going to get something related to S-expressions/Lisp, was disappointed...
The 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?
Ha! I was expecting/wondering something about the semantics of )( parenthesis (which I have no idea what it could be, but... why not?)