I have an assignment to create map_reverse function.
let rec map_rev func = function
[] -> []
| h::t -> map_rev func t # func h;;
let f x = x * 7;;
open Printf
let a = map_rev f [1;2;10;20;400]
let () = List.iter (printf "%d ") a
Now, the compiler will not allow this line:
let a = map_rev f [1;2;10;20;400]
because:
'This expression has type 'a * 'b but an expression was expected of type 'c -> 'd list'.
Could anyone point my mistake? Why does it expect 'c -> 'd list?
The type of a map reverse function should be ('a -> 'b) -> 'a list -> 'b list. Your map_rev function has type ('a -> 'b list) -> 'a list -> 'b list. So the key is to figure out why the compiler thinks func returns a list.
let rec map_rev func = function
[] -> []
| h::t -> map_rev func t # [func h ];;
Related
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.
My current try is this:
let compose_pair (p:(('b -> 'c) * ('a -> 'b))) : 'a -> 'c =
fun x -> fst p (snd p x)
You are writing a function that takes a pair:
fun pair -> ...
and returns a function, which takes some value:
fun pair -> (fun value -> ...)
The return value in the inner function is the composition of the functions stored in the pair.
Your function, as quoted below, appears to work quite well.
let compose_pair (p:(('b -> 'c) * ('a -> 'b))) : 'a -> 'c =
fun x -> fst p (snd p x)
# let compose_pair (p:(('b -> 'c) * ('a -> 'b))) : 'a -> 'c =
fun x -> fst p (snd p x) ;;
val compose_pair : ('b -> 'c) * ('a -> 'b) -> 'a -> 'c = <fun>
# let f = compose_pair ((fun x -> x + 1), (fun x -> x * 2));;
val f : int -> int = <fun>
# f 3;;
- : int = 7
However, it can be cleaned up. You can pattern match a tuple argument to a function directly, rather than calling fst and snd.
let compose_pair (f, g) = ...
You can then produce a function which takes an argument and applies it to these functions.
let compose_pair (f, g) =
fun x -> f (g x)
But we can simplify this further, because let f a b c = ... is the same as writing let f = fun a -> fun b -> fun c -> ....
let compose_pair (f, g) x = f (g x)
Or as an alternative, using the |> operator.
let compose_pair (f, g) x = x |> g |> f
is it possible to write in sml/nj a function with the signature:
fn : 'a -> 'b
my initial purpose was to make a function with the signature:
fn: ( 'a -> 'b ) -> ( 'b -> 'a ) -> 'a -> 'b -> 'c
after many tries I got:
fn: ( 'a -> 'b ) -> ( 'b -> 'a ) -> 'a -> 'b -> 'c -> 'c
but I never succeeded to make as it was asked, and I realized that if it is possible for me to make a function from 'a to 'b I could find the solution.
There are only two possible implementations that give a 'a -> 'b function, and they're rarely useful:
Throwing an Exception
- fun foo a = raise Fail "error";
val foo = fn : 'a -> 'b
Looping Indefinitely
- fun bar a = bar a;
val bar = fn : 'a -> 'b
I have a hunch that some details have been lost in the translation, because the second type signature you've given doesn't make much sense.
is it possible to write in sml/nj a function with the signature:
fn : 'a -> 'b
Yes -- see this StackOverflow question (and make it a habit of checking for duplicates as you ask. ;-)
my initial purpose was to make a function with the signature:
foo : ('a -> 'b) -> ('b -> 'a) -> 'a -> 'b -> 'c
It could be like this:
exception Done
fun foo f g x y _ = (f x; g y; raise Done)
Or like this:
fun foo f g x y _ =
let fun inf () = inf ()
in f x; g y; inf () end
What makes these functions similar to functions with type 'a -> 'b is in fact the 'c part, since this type does not relate to the input types, just like 'b does not relate to 'a. The 'as and 'bs in foo actually serve a purpose and allow for some function application (f x, g y) even though these values cannot be a part of the result, since you have no type-safe way of transforming a value of type 'a or 'b into a value of type 'c.
I would enjoy to receive some helpful comments concerning an example given on:
http://caml.inria.fr/pub/docs/manual-ocaml-400/manual021.html#toc79
7.12 Explicit polymorphic type annotations
type 'a t = Leaf of 'a | Node of ('a * 'a) t
let rec depth : 'a. 'a t -> 'b = function
|Leaf _ -> 1
| Node x -> 1 + depth x
I understand this example function, but when I try to define a 'map-like' function of type
'a. 'a t -> ('a -> 'b) -> 'b t
e.g.:
let rec tmap: 'a. 'a t ->(f:'a->'b) -> 'b t = function
|Leaf x -> Leaf( f x)
|Node x -> let res = tmap x in Node(res);;
I get the following error:
Characters 67-77:
|Leaf x -> Leaf( f x)
^^^^^^^^^^
Error: This expression has type 'c t but an expression was expected of type
(f:'a -> 'b) -> 'b t
which I do not completely understand.
I would appreciate any helpful comment.
You forgot to get the second argument.
let rec tmap:
'a. 'a t ->(f:'a->'b) -> 'b t = (* asking for two arguments *)
function (* takes only the first argument *)
|Leaf x -> Leaf( f x)
|Node x -> let res = tmap x in Node(res);;
Also, 'b must be polymorphic too, as you want to generate nested tuples as long as you descend through the tree.
This should be, thanks to ivg:
let rec tmap : 'a 'b. 'a t -> f:('a->'b) -> 'b t = fun t ~f ->
match t with
|Leaf x -> Leaf( f x)
|Node x -> let f (a,b) = (f a, f b) in Node ( tmap x ~f ) ;;
You have a few problems, like improperly placed parenthesis around f, forgotten argument to the tmap function in the Node branch, and you've forget the quantifier for 'b. So, finally, with the help of PatJ we can write the following:
type 'a t = Leaf of 'a | Node of ('a * 'a) t
let rec depth : 'a. 'a t -> 'b = function
| Leaf _ -> 1
| Node x -> 1 + depth x
let rec tmap: 'a 'b. 'a t -> f:('a -> 'b) -> 'b t =
fun t ~f -> match t with
| Leaf x -> Leaf (f x)
| Node x ->
Node (tmap ~f:(fun (x,y) -> f x, f y) x)
tmap (Node (Leaf (7,8))) ~f:(fun x -> x + 1, x + 2);;
- : (int * int) t = Node (Leaf ((8, 9), (9, 10)))
many thanks for your great help.
Now my test cases work out as intended:
let int_tree = Node(Node(Leaf((3,-1),(0,4))));;
let char_tree = Node(Node(Leaf(('a','c'),('d','c'))));;
tmap int_tree ~f:(fun x -> x*x);;
- : int t = Node (Node (Leaf ((9, 1), (0, 16))))
tmap char_tree ~f:(fun x -> Char.uppercase x);;
- : char t = Node (Node (Leaf (('A', 'C'), ('D', 'C'))))
Is there a way to have a recursive call but with different type parameters?
Here's an example which I think should compile, but doesn't.
let swap (a, b) = (b, a)
module Test : sig
val test : bool option ->
('a -> 'b -> 'c) * ('b -> 'a -> 'c)
-> 'a -> 'b -> 'c
end = struct
let rec test (b : bool option)
(f : ('a -> 'b -> 'c) * ('b -> 'a -> 'c))
(x : 'a) (y : 'b) : 'c =
match b with
| None -> (fst f) x y
| Some true -> (test None f x y)
| Some false -> (test None (swap f) y x)
end
The compiler insists that 'a and 'b must be the same type in test even though there's no reason for it. Is this a bug?
This is actually an very interesting question.
I didn't know the answer before, but by reading through the two answers before me, plus a bit research, I will try explain and answer below.
Basically, what you want to achieve is the signature like this
val test : bool option -> ('a -> 'b -> 'c) * ('b -> 'a -> 'c) -> 'a -> 'b -> 'c
First of all, I have to emphasise that trying to force the parameters to be different polymorphic types, i.e., use 'a, 'b, 'c etc, will not necessarily force OCaml compiler to think that the parameters must have different types.
for example, if you do
let f (x:'a) (y:'b) = x + y;;
It seems you are forcing x and y to be different types, but after compiling, it gives
val f : int -> int -> int = < fun >
Basically, OCaml will anyway do its type inference, and apply the conclusion if it is not just against the forced type.
You may think the 'a and 'b in let f (x:'a) (y:'b) = x + y;; to be maybe x and y will have different types and also possibly same types. So it is pointless to force types of parameters like that, right?
So, let's remove all the types forced on parameters and we get
let rec test b f x y =
match b with
| None -> (fst f) x y
| Some true -> test None f x y
| Some false -> test None (swap f) y x
The type of test will be given by OCaml like this:
val test : bool option -> ('a -> 'a -> 'b) * ('a -> 'a -> 'b) -> 'a ->
'a -> 'b = < fun >
So, basically, OCaml thinks x and y must have the same types, and c is not there because the next available type tag for OCaml to use is 'b.
Why x and y must have same types?
When OCaml meets let rec test b f x y, ok, it will think x has type of 'a and y has type of 'b'.
When OCaml meets | Some true -> test None f x y, no problem, the above type inference still stand because you are pass same x and y to test again.
The the funny part is when OCaml meets | Some false -> test None (swap f) y x. You are trying pass y and x (notice the order) to test. In order to let test work, x and y must have the same type, right?
Basically, above is what the counter side of polymorphism recursion #Jeffrey Scofield answered.
polymorphism recursion means, a function can have some parameters whose types can be changed during recursion, instead of stay constant.
OCaml by default of course only allow constant parameter types.
So how does rank 2 polymorphism work?
So how to solve it?
You need a for_all type 'a.. have a look at my question: In OCaml, what type definition is this: 'a. unit -> 'a.
If we use 'a. or 'a 'b. in type definition, then it means it is really for all types, real polymorphic types, and please, ocaml, do not narrow them down as long as it does not harm.
let rec test : 'a 'b. bool option -> ('a -> 'b -> 'c) * ('b -> 'a -> 'c) -> 'a -> 'b -> 'c =
fun b f x y ->
match b with
| None -> (fst f) x y
| Some true -> test None f x y
| Some false -> test None (swap f) y x
Above is the new version of test.
You force type with 'a 'b. for the function test and for 'a and 'b, ocaml will think they are really both polymorphic, and thus the parameter x and y can be accepted in both orders.
You're asking for polymorphic recursion, for which type inference is undecidable in the general case: Wikipedia on Polymorphic Recursion. So I don't think it's a bug.
I think there are ways to get what you want using rank-2 polymorphism.
I think it's a bug because if you create a new function (identical to the first one), then the type is correct:
# let rec t b f x y = match b with
| true -> (fst f) x y
| false -> u true (swap f) y x
and u b f x y = match b with
| true -> (fst f) x y
| false -> t true (swap f) y x;;
val t : bool -> ('a -> 'b -> 'c) * ('b -> 'a -> 'c) -> 'a -> 'b -> 'c = <fun>
val u : bool -> ('a -> 'b -> 'c) * ('b -> 'a -> 'c) -> 'a -> 'b -> 'c = <fun>
using OCaml 4.01.0:
module rec Test : sig
val test : bool option -> ('a -> 'b -> 'c) * ('b -> 'a -> 'c) -> 'a -> 'b -> 'c
end = struct
let rec test b f x y =
match b with
| None -> (fst f) x y
| Some true -> (Test.test None f x y)
| Some false -> (Test.test None (swap f) y x)
end;;
See the section on Recursive modules.
Small example as a test case:
let add_float_int x y = x +. (float y);;
let add_int_float x y = add_float_int y x;;
let adds = add_float_int, add_int_float;;
List.map (fun x -> Test.test x adds 10 10.) [None; Some true; Some false];;
The title is the question, simple.
The identity function fun x -> x has the type 'a -> 'a.
Are there any other functions with the same type 'a -> 'a?
I can't think of another.
No.
fun x -> print_endline "foo"; x;;
(failwith "bang" : 'a -> 'a);;
(fun x -> failwith "bang" : 'a -> 'a);;
(fun x -> List.hd [] : 'a -> 'a);;
let rec f (x : 'a) : 'a = f x;;
let counter = ref 0;;
(fun x -> incr counter; x);;
The identity function is the only inhabitant of 'a -> 'a in total programming language with no side-effects whatsoever, including nontermination. Neither OCaml nor Haskell qualify, but some languages used as proof assistants (where this totality is important) do, in particular Coq (which has the impredicative polymorphism used to formulate this type).