What programming languages use the pipe operator? I'm only really aware of shell scripting and R that use it.
Why don't more programming languages use the pipe operator? I write a lot of bash, powershell, and recently Nushell. I think piping things together is really powerful. There must be reasons why it's not in languages like python etc.
In other cases, Node.js has .pipe() function.
Other than that, if every class follows the same interface of strings for input and output, the program could pipe internally (and itself participate externally).
Data types let us specialize from plain strings to have better guarantees (safety, performance, specification), but now they are more specific in turn.
Functional programming wise, Python could map over a collection of things, as long as the function knows how to process elements.
Other ideas: fluent interfaces, method chaining, builder design pattern.
I'll try to guess what you mean and answer as best I can; the summary is that I don't think you properly understand what's out there already, so it doesn't make sense to ask "why" questions yet.
If you simply mean the | operator, many programming languages - including Python - define | as a bitwise OR on some numeric types; and many - including Python - allow the user to define its semantics for user-defined types.
That said, it seems more like you really do have specific semantics in mind, rather than that symbol. I don't know R, but based on what my search query turned up first (https://www.statology.org/pipe-in-r/), it seems that by "pipe operator in R" you mean %>%, which allows for chaining operations on an input. In languages that support an object-oriented style with method calls, you do this by just... repeatedly calling methods, and having each return an instance of the type needed for the next step (in common cases, another instance of the same type). There's no need for any special syntax because it's an automatic consequence of how method calls work.
Code is written like that all the time in JavaScript, in fact. In the Python culture, though, there is a relatively strong expectation of command-query separation (https://en.wikipedia.org/wiki/Command%E2%80%93query_separati...). It's still possible to connect operations together this way, but there's an expectation that each operation creates a new result object (even if it's of the same type) and leaves the original input object unmodified. Thus, you're expected to do something with the overall result of such a chain, because your input data hasn't been modified. (This can also be viewed as a functional programming - https://en.wikipedia.org/wiki/Functional_programming - idiom.)