pak VS proposal-pipeline-operator

From your issue link:

> Then commons-logging changes its API incompatibly and is released as commons-logging 2.0.1. Authentication adopts commons-logging 2.0.1 while other libraries still depend on 1.1.1

> Now my-application is broken, because the dependency tree includes two versions of commons-logging which share packages, class / functions names, and thus can not be loaded simultaneously.

I absolutely don't see how this is a problem with semver, it is not the responsibility of semver to tell a language how packages should be isolated and loaded. That is a problem of a) the language and b) dependency resolution in the package manager.

> SemVer is a product of Ruby community.

Bundler, by design, does not allow the above, instead having a flat, consistent vision of dependencies.

NPM though, allows that, allowing nested dependencies, by virtue of the ES6 module system importing to a variable in a lexical scope. Go also allows that, by virtue of its imports being scoped to a package (or file, I can't recall).

Ruby can do that kind of isolation too. In fact, I've done it: https://github.com/lloeki/pak

Unless packages leak to globals each version is oblivious to the one next to it. Unless package dependents communicate with one another using objects from the packages they can happily live in their own world. Now if they do, then it's like hitting a HTTP /api/v1 with an HTTP /api/v2 client and somehow wishing things will work. Either the package (which should not leak globals / disallow cross-version communication) or the language (which should not allow leaking globals / detect incompatible communication).

None of this is the responsibility of semver.

(the link jumps to some random place for me)

Well, you always could, it was just a bit more involved:

https://github.com/lloeki/pak

Current Status: You'd have to check the TC39 proposals repository or the official proposal text for the most recent status. As of my last update, it had not yet reached Stage 4 (final stage) of the TC39 process, which means it wasn't part of the ECMAScript specification yet.

Javascript may get it https://github.com/tc39/proposal-pipeline-operator https://youtu.be/dQw4w9WgXcQ

It can be further simplified. For example, you don't need two separate functions to extract the first chat completion message etc.

This version:

- uses existing language constructs

- can be immediately understood even by the most junior devs

- is likely to be 1000 times faster

- does not rely on an external dependency that currently has 143 issues and every two weeks releases a new version adding dozens of new methods to things

Note: one thing I do wish Javascript adopted is pipes: https://github.com/tc39/proposal-pipeline-operator

Still in stage 2 atm https://github.com/tc39/proposal-pipeline-operator

Both are active tc39 proposals :)

https://github.com/tc39/proposal-pipeline-operator - Stage 2

https://github.com/tc39/proposal-pattern-matching - Stage 1

Hopefully we get both in the next couple of years.

Some time ago I saw how hyped JS community was about pipeline operator proposal. So I tried to make something similar in python. There is how tipe module was created. Check it out if you are interested: https://github.com/mishankov/tipe

We often add promising TC39 proposals into Civet so people can experiment without waiting.

We've added https://github.com/tc39/proposal-pipeline-operator, a variant of https://github.com/tc39/proposal-pattern-matching, a variant of https://github.com/tc39/proposal-string-dedent and others.

Since our goal is to be 99% compatible with ES we'll need to accommodate any proposals that become standard and pick up anything TC39 leaves on the table (rest parameters in any position, etc.)

The Proposal is for the Hack pipe, so your example would be