Is there a modulo equivalent for (<) in functions?

Your first example is incorrect in saying that fun i -> i < 123 is equal to ((<) 123). That is actually equivalent to fun i -> 123 < i. Let me explain, every operator is just a function but infix rather than prefix. As an example

let (+) x y = x + y
let add x y = x + y

let (-) a b = a - b // notice that the first argument (a) is on the left side of the operator
let subs a b = a - b

knowing this, we can then reason about % and < the same way

let (%) x y = x % y
let (<) x y = x < y

// therefore
fun i -> i < 123

// is equivalent to
fun i -> (<) i 123

// and mathematically equiv to 
((>=) 123)

// same with %
fun i -> i % 2

// is equiv to
fun i -> (%) i 2

// thus cant be reduced to eliminate the lambda

Another alternative, if you're dead-set on not writing out the lambda, is to lift it into a function:

let inline isEven x = x % 2 = 0

...

|> Seq.filter isEven

Alas, you are out of luck, because for partial application to be suitable, you need to swap both arguments of the mod operator. The lambda function is way more concise when taking into account that you are applying two operators, which requires function composition.

let flip f a b = f b a
{0..9}
|> Seq.filter ((flip (%) 2) >> ((=) 0))
|> (Seq.map string >> String.concat ", ")
// val it : string = "0, 2, 4, 6, 8"