Comparison of programming languages (algebraic data type)

This article compares the syntax for defining and instantiating an algebraic data type, sometimes also referred to as a tagged union, in various programming languages.

Examples of algebraic data types

ATS

In ATS, an ADT may be defined with:

datatype tree =
| Empty of
| Node of

And instantiated as:

val my_tree = Node

Additionally in ATS dataviewtypes are the linear type version of ADTs for the purpose of providing in the setting of manual memory management with the convenience of pattern matching. An example program might look like:

dataviewtype int_or_string_vt =
| String_vt of string
| Int_vt of int
viewtypedef Int_or_String_vt = int_or_string_vt b
fn print_int_or_string : void =
case+ i_or_s of

| ~String_vt => println!

| @Int_vt => begin
$extfcall;
free@i_or_s;
end
implement main0 : void = let
val string_hello_world = String_vt "Hello, world!"
val int_0 = Int_vt 0
in
print_int_or_string string_hello_world;
print_int_or_string int_0;

end

Ceylon

In Ceylon, an ADT may be defined with:

abstract class Tree
of empty | Node
object empty
extends Tree
final class Node
extends Tree

And instantiated as:

value myTree = Node;

Clean

In Clean, an ADT may be defined with:

= Empty
| Node Int Tree Tree

And instantiated as:

myTree = Node 42 Empty

C++

In C++, an ADT may be defined with:

struct Empty final ;
struct Node final ;
using Tree = std::variant;

And instantiated as:

Tree myTree ;

Dart

In Dart, an ADT may be defined with:

sealed class Tree
final class Empty extends Tree
final class Node extends Tree

And instantiated as:

final myTree = Node, Empty), Empty);

Elm

In Elm, an ADT may be defined with:

type Tree
= Empty
| Node Int Tree Tree

And instantiated as:

myTree = Node 42 Empty

F#

In F#, an ADT may be defined with:

type Tree =
| Empty
| Node of int * Tree * Tree

And instantiated as:

let myTree = Node

F*

In F*, an ADT may be defined with:

type tree =
| Empty : tree
| Node : value:nat -> left:tree -> right:tree -> tree

And instantiated as:

let my_tree = Node 42 Empty

Free Pascal

In Free Pascal, an ADT may be defined with variant records:

program MakeTree;
type TreeKind = ;
PTree = ^Tree;
Tree = record
case Kind: TreeKind of
Empty: ;
Node: ;
end;

And instantiated as:

var MyTree: PTree;
begin new;
with MyTree^ do begin
Value := 42;
new;
with Left^ do begin
Value := 0;
new;
new;
end;
new;
end;
end.

Haskell

In Haskell, an ADT may be defined with:

data Tree
= Empty
| Node Int Tree Tree

And instantiated as:

myTree = Node 42 Empty

Haxe

In Haxe, an ADT may be defined with:

enum Tree

And instantiated as:

var myTree = Node;

Hope

In Hope, an ADT may be defined with:

data tree empty
++ node ;

And instantiated as:

dec mytree : tree;
--- mytree <= node ;

Idris

In Idris, an ADT may be defined with:

data Tree
= Empty
| Node Nat Tree Tree

And instantiated as:

myTree : Tree
myTree = Node 42 Empty

Java

In Java, an ADT may be defined with:

sealed interface Tree

And instantiated as:

var myTree = new Tree.Node, new Tree.Empty),
new Tree.Empty
);

Julia

In Julia, an ADT may be defined with:

struct Empty
end
struct Node
value::Int
left::Union
right::Union
end
const Tree = Union

And instantiated as:

mytree = Node, Empty), Empty)

Kotlin

In Kotlin, an ADT may be defined with:

sealed class Tree

And instantiated as:

val myTree = Tree.Node,
Tree.Empty,

Limbo

In Limbo, an ADT may be defined with:

Tree: adt ;

And instantiated as:

myTree := ref Tree.Node, ref Tree.Empty),
ref Tree.Empty
);

Mercury

In Mercury, an ADT may be defined with:

---> empty
; node.

And instantiated as:

my_tree = node.

Miranda

In Miranda, an ADT may be defined with:

tree ::=
Empty
| Node num tree tree

And instantiated as:

my_tree = Node 42 Empty

Nemerle

In Nemerle, an ADT may be defined with:

variant Tree

And instantiated as:

def myTree = Tree.Node, Tree.Empty),
Tree.Empty,
);

Nim

In Nim, an ADT may be defined with:

type
TreeKind = enum
tkEmpty
tkNode
Tree = ref TreeObj
TreeObj = object
case kind: TreeKind
of tkEmpty:
discard
of tkNode:
value: int
left, right: Tree

And instantiated as:

let myTree = Tree,
right: Tree),
right: Tree)

OCaml

In OCaml, an ADT may be defined with:

type tree =
| Empty
| Node of int * tree * tree

And instantiated as:

let my_tree = Node

Opa

In Opa, an ADT may be defined with:

type tree =
or

And instantiated as:

my_tree =

OpenCog

In OpenCog, an ADT may be defined with:

PureScript

In PureScript, an ADT may be defined with:

data Tree
= Empty
| Node Int Tree Tree

And instantiated as:

myTree = Node 42 Empty

Python

In Python, an ADT may be defined with:

from __future__ import annotations
from dataclasses import dataclass
@dataclass
class Empty:
pass
@dataclass
class Node:
value: int
left: Tree
right: Tree
Tree = Empty | Node

And instantiated as:

my_tree = Node, Empty), Empty)

Racket

In Typed Racket, an ADT may be defined with:

)

And instantiated as:

) ))

Reason

In Reason, an ADT may be defined with:

type Tree =
| Empty
| Node;

And instantiated as:

let myTree = Node;

ReScript

In ReScript, an ADT may be defined with:

type rec Tree =
| Empty
| Node

And instantiated as:

let myTree = Node

Rocq

In Rocq, an ADT may be defined with:

Inductive tree : Type :=

And instantiated as:

Definition my_tree := node 42 empty.

Rust

In Rust, an ADT may be defined with:

enum Tree

And instantiated as:

let my_tree = Tree::Node, Box::new),
Box::new,
);

Scala

Scala 2

In Scala 2, an ADT may be defined with:

sealed abstract class Tree extends Product with Serializable
object Tree

And instantiated as:

val myTree = Tree.Node,
Tree.Empty

Scala 3

In Scala 3, an ADT may be defined with:

enum Tree:
case Empty
case Node

And instantiated as:

val myTree = Tree.Node,
Tree.Empty

Standard ML

In Standard ML, an ADT may be defined with:

datatype tree =
EMPTY
| NODE of int * tree * tree

And instantiated as:

val myTree = NODE

Swift

In Swift, an ADT may be defined with:

enum Tree

And instantiated as:

let myTree: Tree =.node

TypeScript

In TypeScript, an ADT may be defined with:

type Tree =
|
| ;

And instantiated as:

const myTree: Tree = ;

Visual Prolog

In Visual Prolog, an ADT may be defined with:

domains
tree = empty; node.

And instantiated as:

constants
my_tree : tree = node.

Zig

In Zig, an ADT may be defined with:

const Tree = union ;

And instantiated as:

const my_tree: Tree =.;