Did you consider either of those? Were your reasons for preferring Rust similar to what I put in the article?
let (|>) x f = f x
In fact, even the + and - operators are implemented in F# and shouldn't count as part of the language (just very commonly used bits of the stdlib). I fear that perhaps not enough intros to F# focus on the relatively simple underlying language, and that everything else on top is just an application of said language.
With the type system, it's actually easy to figure out the operators, based on the type alone. Looking at |> for instance, we see a type of:
'a -> ('a -> 'b) -> 'b
But it's a valuable comment as it illustrates that the simplicity is not being marketed correctly and turning away potential users.
OCaml and Haskell have somewhat odd syntax, for someone who is coming from C like languages or even Python. You need to learn a bunch of functional programming concepts to use them effectively. You are still limited in what you can do, such as writing a native extension module for your existing Python code base. And they don't really help on one of the major selling points of Rust, which is to be able to write safe multi-threaded code with shared, mutable data structures. While there may be lots of good high-level parallelism available, at some point for certain problems you really just want to be able to use a shared, mutable data structure, but doing so in almost any language but Rust makes it very easy to make a mistake and have aliased, mutable references to it that can invalidate all of your logic, even if it isn't actually memory unsafe.
In Haskell you get correct by default and have to work for speed. In C your program is fast by default, but wrong, and you have to work for correctness.