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'))))
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
Say I have the following
module IntPairs =
struct
type t = int * int
let compare (x0,y0) (x1,y1) =
match Stdlib.compare x0 x1 with
0 -> Stdlib.compare y0 y1
| c -> c
end
module PairsMap = Map.Make(IntPairs)
And I add a few elements:
let m = PairsMap.(empty |> add (1,1) 1 |> add (2,1) 1 |> add (1,2) |> add (2,2))
How would i use to_seq to print keys in ascending order?
I'm not to familiar with iterators in ocaml
This is more of a request for OCaml tutoring than a question about a specific problem in your code. It would generally be faster to read the documentation than to ask individual questions here on StackOverflow.
With that said, the Seq interface looks like this:
type 'a t = unit -> 'a node
and 'a node = Nil | Cons of 'a * 'a t
val empty : 'a t
val return : 'a -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val filter : ('a -> bool) -> 'a t -> 'a t
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val iter : ('a -> unit) -> 'a t -> unit
As you can see, it offers many higher-order traversal functions. The one you would want to use is probably iter since you want to print the values rather than calculate with them. I.e., there is no return value for your desired usage.
However, you should note that the Map interface already has an iter function. As near as I can tell, there's no reason to convert to a sequence before doing your iteration. The Map.iter documentation says this:
The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.
This is what you want, so Map.iter seems like it will do the trick.
PairsMap.iter my_print_function m
(*function f's definition*)
fun f l j y = l j y
val f = fn : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
What does the below line say about the function f ?
val f = fn : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
To answer this question it helps to rename your identifiers:
fun apply g x y = g x y;
val apply = fn : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
apply is equivalent to what you are calling f. What apply does, informally, is take a function, g, of two variables (in curried form) and two arguments x,y and actually applies g to those arguments.
As an example g, define:
fun sum x y = x + y;
val sum = fn : int -> int -> int
Then, for example:
apply sum 5 7;
val it = 12 : int
In the type signature of apply the part
('a -> 'b -> 'c)
is the type of g. It is polymorphic. You can apply any function to arguments of an appropriate type. When you actually use apply (as I did above with sum) then the SML compiler will have enough information to figure out what concrete types correspond to the type variables 'a, 'b, 'c. the overall type of apply is
('a -> 'b -> 'c) -> 'a -> 'b -> 'c
which says that apply is a function which, when fed a function of type ('a -> 'b -> 'c) and arguments of type 'a and 'b, produces a result of type 'c. I'm not sure of any immediate use of apply, though it does serve to emphasize the perspective that functional application is itself a higher-order function.
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).