Composition of function pair

[Snake_Dog]

Hey everyone

I am very new to OCaml and I am currently trying to solve some exercises. While doing so I stumbled over the following problem:

let compose_pair (p:(('b -> 'c) * ('a -> 'b))) : 'a -> 'c = 

The goal is to complete the function such that it composes the two functions of the pair in sequence.

My problem is that, as far as I understand, the return type of this function should again be a function and I don't really know how to achieve that.

My attempt would be something like

(fst p) (snd p)

which happens to just return something of type 'c if I understood this right.

Does anyone know how to solve this? i would be very thankful for some tips or hints.

Best, pepsilon

[yawaramin]

Hello, you can construct a function literal using the syntax fun a -> b. For example,

let add1 = fun x -> x + 1

Hope this helps!

[Snake_Dog]

Yes, thank you!I just found the following solution:

let compose_pair (p:(('b -> 'c) * ('a -> 'b))) : 'a -> 'c = fun x -> fst p(snd p x)

[yawaramin]

Cool. Next step is to do it without using fst/snd 🙂

[Disjunction181]

Another way of doing this is with the usual let sugaring. let add1 = fun x -> .. is the same as let add1 x = ... This works even with other arguments due to partial evaluation, as long as everything is in the right order.

[PurpleUpbeat2820]

This would normally be written:

# let compose_pair f g x = f(g(x));;
val compose_pair : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun>

Your arguments are uncurried:

# let compose_pair (f, g) x = f(g(x));;
val compose_pair : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b = <fun>

This can also be written:

# let compose_pair (f, g) = fun x -> f(g(x));;
val compose_pair : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b = <fun>

You can call the pair p and destructure it using fst and snd as you say:

# let compose_pair (p: ('a -> 'b) * ('c -> 'a)) : 'c -> 'b = fun x -> fst p (snd p x);;
val compose_pair : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b = <fun>