I stumbled upon the Luhn algorithm which is used to check that credit card numbers (amongst other things) are valid. it is pretty simple and is explained on Wikipedia.

At the foot of the Wikipedia page there are heaps of links to implementations in different languages but I noticed F# was missing! Time to have a go at writing one myself then..

As I said it is pretty simple and I soon came up with the following (slicker than the Python entry :-P )...

let luhn_check (code : string) =
code
|> Array.of_seq
|> Array.map (fun c -> int(c) - 48)
|> Array.rev
|> Array.fold_left (
fun (i, s) d -> (3-i, s+ (i*d-1)%9+1) ) (1,0)
|> fun (i,s) -> s % 10 = 0

With the following interactive test ..

> luhn_check "1234567890123456" ;;
val it : bool = false
> luhn_check "1234567890123452" ;;
val it : bool = true

I bumped into variations of the same problem three times in writing this function...

First. Ideally I would like to fold the array from the right.
The problem is that the parameter that takes the input array in the Array.fold_right function isn't the last one so I can't pipeline into it.
I chose to reverse the array and use a fold_left instead which seems a bit wasteful.
Is there a reason why the fold_right parameters are in the order they are, and not in the same order as for the fold_left? I would like to use the fold_right function but pipeline the array into it.

Second. My original attempt at changing a string of characters into integers included the following line :
code |>

Array.of_seq |>
Array.map (int >> (-) 48) |>
...

The problem is that what I have written will subtracts the ASCII values from 48 rather than the other way round.

Third. At one time I was wondering whether I could pipeline the result of my folding directly into the (%) operator on the last line and this suffers from same issue. It will treat the pipelined value as the base for the modulus and not the 'modulee' (I know that the result of my folding is a tuple rather than an integer, so I need an anonymous function to select the checksum value before doing the % anyway. But lets just say that my folding *had* produced an integer, wouldn't it be cool to just pipe it in)

So on three ocasions I have wanted to control the position of a pipelined parameter in a function.

I naively tried defining my own 'swapped' forward pipeline operator (for functions that take two arguments) as follows :

let inline (|>~) f g h = f h g

I think this looks OK..
> (|>~);;
val it : (('a -> 'b -> 'c) -> 'b -> 'a -> 'c) = <fun:clo@8>

It works fine when used as a function e.g.
> (|>~) (%) 5 7;;
val it : int = 2

but not when used as an inline operator e.g.

> 7 |>~ (%) 5;;

7 |>~ (%) 5;;
^^

stdin(9,1): error FS0001: This expression has type
int
but is here used with type
'a -> 'b -> 'c.

What am I doing wrong? .. or is what I am attempting possible?

As I've said, I couldn't use such an operator for my 'mod 10' test directly (because I am pipelining a tuple) but I might be able to use it (or something similar) to pipeline arrays into the Array.fold_right function.
A similar variant to the function composition operator (>>) would be nice too.
I was aiming for writing the function something like the following (with |>~ and >>~ to be defined):

let luhn_check (code : string) =

code

|> Array.of_seq

|> Array.map (int >>~ (-) 48)

|>~ Array.fold_right (fun (i, s) d -> (3-i, s+ (i*d-1)%9+1) ) (1,0)

|> fun (i,s) -> s % 10 = 0

I suppose one obvious answer is to use the existing operators and define simple wrappers around the functions I am interested in and re-order their parameters.

It would help deepen my knowledge of F# if I knew how I could define new operators that could do this for me though.