CODEWITHSUNDEEP
sml
Martin Thurau
Martin Thurau

Reputation: 7644

Type inference in SML

I'm currently learning SML and I have a question about something I have no name for. Lets call it "type alias" for the moment. Suppose I have the following datatype definition:

datatype 'a stack = Stack of 'a list;

I now want to add an explicit "empty stack" type. I can to this by adding it to the datatype:

datatype 'a stack = emptystack | Stack of 'a list;

Now I can pattern match a function like "push":

fun push (emptystack) (e:'a) = Stack([e])
  | push (Stack(list):'a stack) (e:'a) = Stack(e::list);

The problem here is that Stack([]) and emptystack are different but I want them to be the same. So every time SML encounters an Stack([]) it should "know" that this is emptystack (in case of push it should then use the emptystack match).

Is there a way to achieve this?

Upvotes: 1

Views: 1183

Answers (3)

Jesper.Reenberg
Jesper.Reenberg

Reputation: 5944

The short answer is: No, it is not possible.

You can create type aliases with the code

type number = int

val foo : number -> int -> number =
 fn a => fn b => a+b

val x : int = foo 1 3;
val y : number = foo 1 3;

However, as the name says, it only works for types. Your question goes for value constructors, which there is no syntax for.

Upvotes: 2

sshine
sshine

Reputation: 16105

Since what you want is for one value emptystack to be synonymous with another value Stack [], you could call what you are looking for "value aliases". Values that are compared with the built-in operator = or pattern matching will not allow for aliases.

You can achieve this by creating your own equality operator, but you will lose the ability to use the built-in = (since Standard ML does not support custom operator overloading) as well as the ability to pattern match on the value constructors of your type.

Alternatively, you can construct a normal form for your type and always compare the normal form. Whenever practically feasible, follow Sebastian's suggestion of no ambiguity. There might be situations in which an unambiguous algebraic type will be much more complex than a simpler one that allows the same value to be represented in different ways.

Upvotes: 0

Sebastian Paaske Tørholm
Sebastian Paaske Tørholm

Reputation: 50858

Such an aliasing is not possible in SML.

Instead, you should design your datatypes to be unambiguous in their representation, if that is what you desire.

You'd probably be better suited with something that resembles the definition of 'a list more:

datatype 'a stack = EmptyStack | Stack of 'a * 'a stack;

This has the downside of not letting you use the list functions on it, but you do get an explicit empty stack constructor.

Upvotes: 2

Related Questions