pointfree | pointfree version of ImmutableJS

Yes, it is:

Well, a data type isn't a function. As long as your function isn't unwrapping any data values (i.e. it's just shuffling them between functions/constructors), you can write it point free, but there's simply no syntax for point free matching. However, you only ever need one non-point-free function per data type: the fold. In Haskell, data types are pretty much defined by their folds. Taking the folds of the relevant data types as primitives, you can rewrite any function point free. Note that there are actually several possible "folds". For [a], the recursive one (which comes from the Church/Böhm-Berarducci encoding) is foldr :: (a -> b -> b) -> b -> [a] -> b. Another possible fold is the "case-but-it's-a-function" one, (a -> [a] -> b) -> b -> [a] -> b, which comes from the Scott encoding (recursion can then be recovered with fix, which is another "pointful pointfree primitive"), but, as @SilvioMayolo notes, there isn't such a function in the standard library. Either would do, but we don't have the latter predefined so let's just use foldr.

I highly suspect that this is impossible as the order of the dependencies is reversed. If the object were to be supplied first that would not be an issue.

Right now you would have to specify the type of the object manually via the generics, e.g.:

If trying to set up the binaries for the atom-haskell package (or applicable dependencies), I was able to successfully install the dependencies by using different long term support stack versions. For ghc-mod, hoogle, pointful, and cabal-install I used lts-9.21 and for hasktags, pointfree, and brittany I used lts-11.22 =>

I'll answer your question eventually, but let's take a step back first.

An important thing to understand is that the pipe method is just function application. In other terms: future.pipe (f) == f (future).

This means that your pipe function can be redefined as such:

swap [[>] dip] filter won’t work because it assumes n is accessible for each call to the quotation by which you’re filtering; that implies filter can’t leave any intermediate values on the stack while it’s operating, and > doesn’t consume n. You need to capture the value of n in that quotation.

First “eta”-reduce the list parameter:

Generally (?) (where ? stands for an arbitrary infix operator) is the same as \x y -> x ? y. So we can rewrite f as:

One solution would be to do something like this:

Yes, it's possible: