In F# some types have a special generic syntax (I'm not sure what it is called) so that you can do:
int list // instead of List<int>
int option // instead of Option<int>
- What is this syntax called?
- Can I enable it for my own types?
In F# some types have a special generic syntax (I'm not sure what it is called) so that you can do:
int list // instead of List<int>
int option // instead of Option<int>
It is covered in the MSDN on F# Types
Under "generic type":
generic type
type-parameter generic-type-name |
'a listOr
generic-type-name<type-parameter-list> |
list<'a>
And "constructed types":
constructed type (a generic type that has a specific type argument supplied)
type-argument generic-type-name
or
generic-type-name<type-argument-list>
type dave<'a> = {
V : 'a
};;
let stringDave: dave<string> = { V = "string" };;
//val stringDave : dave<string> = {V = "string";}
let intDave : int dave = { V = 123 };;
//val intDave : dave<int> = {V = 123;}
Firstly, it's important to note that the difference between list and List isn't directly related to the prefix and postfix syntax. The type 'T list is simply an alias of the type List<'T>. From the F# core source code:
type List<'T> =
| ([]) : 'T list
| (::) : Head: 'T * Tail: 'T list -> 'T list
interface System.Collections.Generic.IEnumerable<'T>
interface System.Collections.IEnumerable
interface System.Collections.Generic.IReadOnlyCollection<'T>
interface System.Collections.Generic.IReadOnlyList<'T>
and 'T list = List<'T>
And separate to this we have the ability to express any generic types prefix or postfix.
With these two things combined, that means that all of these types are valid and equivalent.
int list
int List
list<int>
List<int>
This works with any other .NET types, e.g. int System.Collections.Generic.HashSet, and your own types:
type MyCoolType<'a> = A | B
let x : int MyCoolType = A
// compiles ✔
Both the lower-case type annotations and the postfix syntax seem to exist for compatibility with OCaml, which was the language that F# was originally based on.