Comment by sterlind | Hacker News Reader

Comment by sterlind | Hacker News Reader

Parent Full thread

Yes, Pure is a term-rewriting system, similar to SymPy. Transformation rules define patterns to match in expressions, what bindings to capture from the match, and what to transform the matched pattern into. This is also how the XL language seemed to work.

The major difference between a term-rewriting system and a general-purpose functional/declarative language is that you don't need to define everything. Expressions will be transformed until they can't anymore, and then they're left alone. So you can e.g. implement symbolic differentiation as a set of rules, and take the derivative of a symbolic expression, because the variables (or even entire functions!) just don't need to be defined.

The king of all term-rewriting systems is (imo) Mathematica. It's extraordinarily powerful, capable of matching subtrees and variable arity expressions and it's perfect for doing card tricks with algebraic identities. Unfortunately proprietary.

Sadly, term-rewriting languages are languishing. Even Pure is pretty dead.

Its a shame, because there is a lot of really cool stuff you can do when you're able to work with your code in algebraic terms.

Just as one simple example:

Suppose you have defined some expressions that describe how to read/write data from a database, and you have used them to define a workflow-expression that retrieves a bunch of data, does some math on it, and displays the result.

In Mathematica, you can plug that whole workflow-expression into the "Simplify" function and it will potentially eliminate entire database calls if it realizes you've got stuff like "GetData[y]*(GetData[x]-GetData[x])" in your result that will always evaluate to 0.

You can even do things like define a high "complexity" of your GetData functions to make the Simplify function look for an algebraic form that will minimize calls to the database, even if it has to make the algebra look uglier.

Wow, this sounds like something with a lot of potential.

It also makes me think the book Algebra-Driven Design[1]. That coupled with what you're describing sounds like a powerful combination.

[1]: https://reasonablypolymorphic.com/blog/algebra-driven-design...

This library bring these capabilities to Clojure:

https://github.com/mentat-collective/emmy

It's based on an older library for Scheme, by Sussman.

Yep. Mathematica is what I think about when I hear TRS. There is a good video by a Gaylord something or another where he explains how the Wolfram Mathematica language evaluates expressions.

Mathematica is extremely powerful and very cool. The only thing that isn't cool is the fact that it's commercial.

Edit: Found the video https://youtu.be/H-rnezxOCA8?feature=shared

Mathematica user since 1988: i think it, in retrospect, might be great that it’s proprietary, in that it dampens its likelihood of trend-driven over commitment and resulting irrelevance.

> Mathematica user since 1988: i think it, in retrospect, might be great that it’s proprietary, in that it dampens its likelihood of trend-driven over commitment and resulting irrelevance.

I think that's not really true. It's not that Mathematica isn't trend-driven, just that it's responsive to trends more or less to the extent that Wolfram (company or person) is, rather than to the extent that the entire developer community is. Depending on how you use it, you may or may not like its embrace of new trends; while I've occasionally been glad it can do $CoolThing, I have also wondered sometimes why my Mathematica install needed to grow from, at some point in the single-digit versions where it was perfectly useful, a few hundred megabytes to now nearly 9 GB.

The install is freaking massive as it's practically an entire computational/scientific OS at this point.

i wonder the same. perhaps the addition of parsers and generators for all the myriad explosion of formats (file and otherwise) since 1988 is part of the problem.

Maude is a good one, too. The K Framework people built on Maude. Then, they built the formal semantics of C on it which they use to prove absence of specific errors. Shows how practically useful these things can be.

Unfortunately, the official documentation is not very good.

Reply on news.ycombinator.com