What is the state of the art minification/compression?

garyb · January 14, 2021, 2:00pm

Ah that’s a shame, thanks for pursuing it with the closure team anyway!

jamesbrock · September 26, 2021, 2:56pm

This is interesting:

“Just in case anyone else is wondering about prepack and purescript:” Inlining · Issue #2345 · purescript/purescript · GitHub

chrisdone · December 22, 2021, 12:49pm

Some kind person commented that apparently a version of Closure with the right flag does in fact reduce curried functions:

github.com/google/closure-compiler

Uncurrying

opened 01:20PM - 30 Oct 20 UTC

closed 11:56PM - 13 Jan 21 UTC

chrisdone

feat

One thing that functional languages like PureScript do is generate curried funct…ions. This appears to be a blocker for Closure. For example, ```javascript (function(){ var Show_string = { show: function(s){ return s; } }; function print(d,v){ console.log(d.show(v)); } function greet(d,v){ return print(d,v + "!"); } return greet(Show_string, "Mary"); })(); ``` Closure outputs, ```javascript console.log("Mary!"); ``` Excellent result. It did pretty straight-forward transformations here. Including removing the overhead of generic functions, which are achieved via dictionary (argument) passing in Haskell-like languages. However, in languages like Haskell/PureScript, functions are all single-argument chains of functions, like this: ```javascript (function(){ var Show_string = { show: function(s){ return s; } }; function print(d) { return function(v){ console.log(d.show(v)); } } function greet(d){ return function(v){ return print(d)(v + "!"); } } return greet(Show_string)("Mary"); })(); ``` Unfortunately, Closure outputs the following: ```javascript (function() { function c(a) { return function(b) { console.log(a.show(b)); }; } return function(a) { return function(b) { return c(a)(b + "!"); }; }({show:function(a) { return a; }})("Mary"); })(); ``` This means that PureScript's output is both large _and_ slow -- this example is small, but imagine large codebases with nested levels of this. So it seems that "uncurrying" is not a process that Closure currently does. I'm not sure whether this was decided against, simply because it's not normal in JS to have functions like this, or whether it's an oversight, or whether there's a good reason that makes reducing these in the general case difficult. Could someone fill me in? If it's simply not something considered, how difficult would it be to add? Is it something I could implement myself in Closure? I'm discussing with the PureScript community and considering whether to add it to the compiler output, but on the other hand, this kind of thing feels like Closure's bread and butter, so I'm attempting to do it the Right Way before going off and patching something further up the chain.

I haven’t tested it yet, but this is very encouraging!

sigma-andex · December 28, 2021, 4:29pm

@i-am-the-slime and I tried it out for the es modules branch and we were able to reproduce the results. Here some more details: `purs bundle` · Issue #1 · working-group-purescript-es/purescript · GitHub