I am learning OCaml and so far I am having trouble to understand the concepts of types.
For example, if we have this following code:
# let func x = x;;
val func : 'a -> 'a = <fun>
From the official website, it tells me that 'a before the arrow is the unknown input type and 'a after the arrow is the output.
However, when I try to use function composition:
# let composition f x = f(x);;
val composition : ('a -> 'b) -> 'a -> 'b = <fun>
What ('a -> 'b) means?
Is 'a related to f and 'b related to x?
Another function composition that made me even more confused is:
# let composition2 f x = f(f(x));;
val composition2 : ('a -> 'a) -> 'a -> 'a = <fun>
I don't really understand why we don't have the 'b in this case.
Thank you in advance!
'a -> 'b is the type of a function that takes one argument of type 'a and returns a value of type 'b.
val composition : ('a -> 'b) -> 'a -> 'b means that composition is a function of two arguments:
the first one is of type ('a -> 'b), so a function as above
the second one is of type 'a
So, this function returns something of the same type as the return type of the first argument, 'b. Indeed, it takes a function and its argument and applies that function to the argument.
In the second case, you can work backwards from the inner call. Let's have a look at f(f(x))
x is something of any type 'b. We have no idea what kind of type this is yet.
Since we have f(x), f must be a function of type 'b -> 'c. It's 'b because we know it takes x as input, and x is of type 'b.
Thus, the type of composition2 is ('b -> 'c) -> 'b
Since we have f(f(x)), the type of f's argument must be the same as the type of its return value. So, 'b == 'c. Call that type 'a.
Since x is of type 'b, which is the same as 'a, x must be of type 'a.
Since f is of type 'b -> 'c, where 'b == 'a and 'c == 'a, f must be of type 'a -> 'a.
Thus, the type of composition2 is ('a -> 'a) -> 'a
Related
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
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.
(*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.
I'm having a bit of difficulty figuring out how to parenthesize a function (when it's legal to add parentheses around certain parts to make the meaning clearer).
For instance, foldl is defined as having type:
foldl : ('a * 'b -> 'b) -> b -> 'a list -> 'b
Now, if I look at foldl's definition, I see:
fun foldl g z [] = z
| foldl g z (x::L) = foldl g (g(x,z)) L;
Based on this, I usually just mentally map g to ('a * 'b -> 'b), z to be of type 'b, and pattern-matching takes care of the list of type 'a list. Finally, the return type is 'b.
However, I thought -> right associates, so wouldn't it be most natural to start by saying "OK, add parentheses like so:
foldl : ('a * 'b -> 'b) -> 'b -> ('a list -> 'b)
What's wrong with this line of thought / what am I misunderstanding about how to add parentheses?
There's nothing wrong with it, it's just redundant.
('a * 'b -> 'b) -> 'b -> ('a list -> 'b), ('a * 'b -> 'b) -> ('b -> ('a list -> 'b)) and ('a * 'b -> 'b) -> 'b -> 'a list -> 'b are all equivalent because -> is right associative. So we usually write the version with the least parentheses (just like one usually writes 3 - 2 - 1 rather than the equivalent (3 - 2) - 1).
Declare on the follow function -
fun act(f,x) = f(x);
Makes the signature -
val act = fn : ('a -> 'b) * 'a -> 'b
What does ('a -> 'b) * 'a -> 'b means ?
It means that act is a function that takes a pair (2-tuple)
('a -> 'b) * 'a
where the first element is a function from 'a to 'b, and the second is a thing of type 'a.
It returns a thing of type 'b.