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.
Related
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
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
Whilst revising for my programming languages exam, there are a few type inference questions for the Standard ML section, I can do most of them by doing type inference in my head, and I'm quite good at it, however there is one question that leaves me stumped.
I have to write a function of type:
('a -> ('b -> 'c)) -> ('a -> 'b) -> ('a -> 'c)
So in my head I should have a function with two arguments that are functions, f and g. Both would take an argument, x, but I cannot add that argument x into this function as it only takes two arguments, so I am left to create this function using the o operator, for pipe-lining functions.
So f takes an argument, and returns a function
g takes an argument, and returns a value.
Then the overall function takes a value and returns a value.
I'm not sure how I can apply f and g using only the o operator to imply those rules.
Any help would be extremely appreciated :)
Thanks, Ciaran
As you already mentioned, you need to write a function of two arguments:
fun my_function f g = body
where f : 'a -> 'b -> 'c and g : 'a -> 'b and body : 'a -> 'c.
Since body has type 'a -> 'c, we can write it as
body = fn x => body'
where body' has type 'c and x : 'a.
Observe, that f x : 'b -> 'c and g x : 'b, and if you have a function of type 'b -> 'c and a value of type 'b it's easy to construct a value of type 'c by applying the function to the argument: (f x) (g x).
The above gives us:
fun my_function f g = fn x => (f x) (g x)
or, alternatively, moving x to the left-hand side of the definition we get:
fun my_function f g x = f x (g x)
By the way, if you are familiar with combinatory logic, then you could notice that the resulting function represents the S combinator.
(*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.
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).