F #, implement fold3, fold4, fold_n

For fold3

you can simply do zip3

and then fold

:

let polynomial (x:double) (a, b, c) = a*x + b*x*x + c*x*x*x
List.zip3 A B C |> List.fold polynomial 0.7

      

        
        
        
      

    

But if you want this for the general case, you need what we call "applicative functors".

First, imagine you have a list of functions and a list of values. Let's assume they are now the same size:

let fs = [ (fun x -> x+1); (fun x -> x+2); (fun x -> x+3) ]
let xs = [3;5;7]

      

        
        
        
      

    

And what you would like to do (natural only) is apply each function to each value. This can be easily done with List.map2

:

let apply fs xs = List.map2 (fun f x -> f x) fs xs

apply fs xs  // Result = [4;7;10]

      

        
        
        
      

    

This "applies" operation is why they are called "applicative functors". Not only some functors, but also applicative ones. (the reason why they are "functors" is a little more complicated)

So far so good. But wait! What if every function in my function list returns a different function?

let f1s = [ (fun x -> fun y -> x+y); (fun x -> fun y -> x-y); (fun x -> fun y -> x*y) ]

      

        
        
        
      

    

Or, if I remember that fun x -> fun y -> ...

you can write in short formfun x y -> ...

let f1s = [ (fun x y -> x+y); (fun x y -> x-y); (fun x y -> x*y) ]

      

        
        
        
      

    

What if I have apply

such a list of functions for my values? Well, naturally I'll get another list of functions:

let f2s = apply f1s xs
// f2s = [ (fun y -> 3+y); (fun y -> 5+y); (fun y -> 7+y) ]

      

        
        
        
      

    

Hey, here's the idea! Since f2s

it is also a list of functions, can I apply it again? Well, of course I can!

let ys = [1;2;3]
apply f2s ys  // Result: [4;7;10]

      

        
        
        
      

    

Wait what? What just happened?
First, I applied the first list of functions to xs

and ended up with another list of functions. And then I applied this result to ys

and got a list of numbers.
We could rewrite this without an intermediate variable f2s

:

let f1s = [ (fun x y -> x+y); (fun x y -> x-y); (fun x y -> x*y) ]
let xs = [3;5;7]
let ys = [1;2;3]
apply (apply f1s xs) ys  // Result: [4;7;10]

      

        
        
        
      

    

For added convenience, this operation is apply

usually expressed as an operator:

let (<*>) = apply
f1s <*> xs <*> ys

      

        
        
        
      

    

See what I did there? With this operator, it now looks a lot like just calling a function with two arguments. Well appointed.

But wait. How about our initial challenge? In the original requirements, we don't have a feature list, we only have one feature.
Well, it can easily be fixed with another operation, let's call it "apply first". This operation will take a single function (not a list) plus a list of values ​​and apply this function to each value in the list:

let applyFirst f xs = List.map f xs

      

        
        
        
      

    

Oh wait. It's simple map

. Silly me :-)
For the added convenience of this operation, you usually also assign an operator name:

let (<|>) = List.map

      

        
        
        
      

    

And now I can do things like this:

let f x y = x + y
let xs = [3;5;7]
let ys = [1;2;3]
f <|> xs <*> ys  // Result: [4;7;10]

      

        
        
        
      

    

Or that:

let f x y z = (x + y)*z
let xs = [3;5;7]
let ys = [1;2;3]
let zs = [1;-1;100]
f <|> xs <*> ys <*> zs  // Result: [4;-7;1000]

      

        
        
        
      

    

Well appointed! I did this to apply arbitrary functions to argument lists right away!

Now, finally, you can apply this to your original problem:

let polynomial a b c (x:double) = a*x + b*x*x + c*x*x*x
let A = [2.0; 3.0; 4.0; 5.0]
let B = [1.5; 1.0; 0.5; 0.2]
let C = [0.8; 0.01; 0.001; 0.0001]

let ps = polynomial <|> A <*> B <*> C
let result = ps |> List.fold (fun x f -> f x) 0.7

      

        
        
        
      

    

The list ps

consists of instances polynomial

that are partially applied to the matching elements A

, B

and C

, and still expect a final argument x

. And on the next line, I just add up this list of functions, applying each one to the result of the previous one.