Type Literals / Enums / Constants

[machaval]

Type Literals / Enums / Constants

Problem statement

We have introduce Type Literals some time ago and it is really good as it allows us to support different patterns like Enumerations or Value Discrimintators.

Let's take an example

type HTTP_METHOD = "GET" | "POST" | "PUT" | "PATCH"

fun request(method: HTTP_METHOD) = do {
	method  match {
		case is "GET" -> "Getting something"
		case is "POST" -> "Posting something"
		case is "PUT" -> "Putting something"
		case is "PATCH" -> "Patching something"
	}
}

---
request("GET")

This script validates as we are invoking the request function with "GET" as it is part of the Union options. And if we provide a wrong option like request("test") it will fail with

- Expecting Type: `"GET"`, but got: `"test"`.
	|-- From: `"GET"`
	|---- From: `HTTP_METHOD`
- Expecting Type: `"POST"`, but got: `"test"`.
	|-- From: `"POST"`
	|---- From: `HTTP_METHOD`
- Expecting Type: `"PUT"`, but got: `"test"`.
	|-- From: `"PUT"`
	|---- From: `HTTP_METHOD`
- Expecting Type: `"PATCH"`, but got: `"test"`.
	|-- From: `"PATCH"`
	|---- From: `HTTP_METHOD`

13| request("test")
            ^^^^^^
Location:
main (line: 13, column:9)

Not only it helps you with type checking information our tools understand the types and autocompletion will suggest the correct literals.

My only problem with the current approach that I don't suffer in Java, scala, rust or any other language that has enums is that I need to duplicate the string "GET" too many times case is "GET" -> "Getting something", request("GET") and type HTTP_METHOD = "GET". We can improve the code by introducing a constant

var GET_METHOD = "GET"
type GET_METHOD_TYPE = "GET"
type HTTP_METHOD = GET_METHOD_TYPE | "POST" | "PUT" | "PATCH"



fun request(method: HTTP_METHOD) = do {
	method  match {
		case is GET_METHOD_TYPE -> "Getting something"
		case is "POST" -> "Posting something"
		case is "PUT" -> "Putting something"
		case is "PATCH" -> "Patching something"
	}
}

---
request(GET_METHOD)

And "fix" the issue but the problem is still there, if tomorrow I need to change that value I need to modify it in two different places.

Proposed Solution

The proposed solution is to be able to reference literal vars as literal types. Let's change the code

var GET_METHOD = "GET"
var POST_METHOD = "POST"
var PUT_METHOD = "PUT"
var PATCH_METHOD = "PATCH"


type HTTP_METHOD = GET_METHOD | POST_METHOD | PUT_METHOD | PATCH_METHOD



fun request(method: HTTP_METHOD) = do {
	method  match {
		case is GET_METHOD -> "Getting something"
		case is POST_METHOD -> "Posting something"
		case is PUT_METHOD -> "Putting something"
		case is PATCH_METHOD -> "Patching something"
	}
}

---
request(GET_METHOD)

With this new change I don't longer need to declare the GET_METHOD_TYPE as a var with a constant can be used as a Type Literal expression and so change it changes everywhere.

What kind of vars can be used?

Only literal expression that are : String, Boolean or Number

If it is something else it will report an error saying that it can not be referenced from a type expression

Other languages

Type script doesn't allow this but they have an operator called typeOf that allows you to do this

type Easing = typeof ease | "ease-out" | "ease-in-out";

let ease = "ease-in"

[rhoegg]

To be clear, are there any constraints on the types of the referenced vars? for example:

var STATUS_OK = "OK"
var NO_RESULT = null

type CommandResult = Array<String> | STATUS_OK | NO_RESULT

[machaval]

Yes ! let me add this to the document. Only String, Boolean and Number literals so null will not. Though I don't see why we can not add null to the list