Types

FTL supports the following types: Int (64-bit), Float (64-bit), String, Bytes (a byte array), Bool, Time, Any (a dynamic type), Unit (similar to "void"), arrays, maps, data structures, and constant enumerations. Each FTL type is mapped to a corresponding language-specific type. For example in Go Float is represented as float64, Time is represented by time.Time, and so on.

User-defined types referenced by a verb will be automatically exported as FTL types.

Basic types

The following table shows how FTL types map to language-specific types:

Go

FTL	Go
Int	int
Float	float64
String	string
Bytes	[]byte
Bool	bool
Time	time.Time
Any	External
Unit	N/A
Map<K,V>	map[K]V
Array<T>	[]T

Kotlin

FTL	Kotlin
Int	Long
Float	Double
String	String
Bytes	ByteArray
Bool	Boolean
Time	ZonedDateTime
Any	External
Unit	N/A
Map<K,V>	Map<K,V>
Array<T>	List<T>

Java

FTL	Java	Java (optional)
Int	long	Long
Float	double	Double
String	String	@Nullable String
Bytes	[]byte	@Nullable byte[]
Bool	boolean	Boolean
Time	ZonedDateTime️	@Nullable ZonedDateTime
Any	External	External
Unit	void	N/A
Map<K,V>	Map<K,V>	@Nullable Map<K,V>
Array<T>	List<T>	@Nullable List<T>

Data structures

FTL supports user-defined data structures, declared using the idiomatic syntax of the target language.

Go

type Person struct {
  Name string
  Age  int
}

Kotlin

data class Person(
  val name: String,
  val age: Int
)

Java

public class Person {
  private final String name;
  private final int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

Generics

FTL has first-class support for generics, declared using the idiomatic syntax of the target language.

Go

type Pair[T, U] struct {
  First  T
  Second U
}

Kotlin

data class Pair<T, U>(
  val first: T,
  val second: U
)

Java

public class Pair<T, U> {
  private final T first;
  private final U second;

  public Pair(T first, U second) {
    this.first = first;
    this.second = second;
  }
}

Type enums (sum types)

Sum types are supported by FTL's type system.

Go

Sum types aren't directly supported by Go, however they can be approximated with the use of sealed interfaces:

//ftl:enum
type Animal interface { animal() }

type Cat struct {}
func (Cat) animal() {}

type Dog struct {}
func (Dog) animal() {}

Kotlin

Sum types aren't directly supported by Kotlin, however they can be approximated with the use of sealed interfaces:

@Enum
sealed interface Animal

@EnumHolder
class Cat() : Animal

@EnumHolder
class Dog() : Animal

Java

TODO

Value enums

A value enum is an enumerated set of string or integer values.

Go

//ftl:enum
type Colour string

const (
  Red   Colour = "red"
  Green Colour = "green"
  Blue  Colour = "blue"
)

Kotlin

@Enum
public enum class Colour(
  public final val `value`: String,
) {
  Red("red"),
  Green("green"),
  Blue("blue"),
  ;
}

Java

@Enum
public enum Colour {
  Red("red"),
  Green("green"),
  Blue("blue");

  private final String value;

  Colour(String value) {
    this.value = value;
  }
}

Type aliases

A type alias is an alternate name for an existing type. It can be declared like so:

Go

//ftl:typealias
type UserID string

Kotlin

typealias UserID = String

Java

// Java does not support type aliases directly
// Use a wrapper class instead
public class UserID {
    private final String value;

    public UserID(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

Type aliases are useful for making code more readable and type-safe by giving meaningful names to types that represent specific concepts in your domain.