• D

struct Vertex
{
	float x, y, z;
	Vertex* [] adjacentVertices;
}

• Go

type Vertex struct{
	Id int
	Label string
	Neighbours map[*Vertex]bool
}

type Graph []*Vertex

• Go

type Graph[L any] []*Vertex[L]

type Vertex[L any] struct {
	Label      L
	Neighbours map[*Vertex[L]]bool
}

• Haskell

datatype Node = Int
datatype Adjacencies = [ Node ]
datatype Graph = [ Adjacencies ]

• Java

class Graph{
  List<Vertex> vertices;

  static class Vertex{
    int id;
    List<Vertex> neighbours;
  }
}

• Java

class Graph{
  Set<Vertex> vertices;

  static class Vertex{
    int id;
    Set<Vertex> neighbours;
  }
}

• Kotlin

inline class VertexId(val id: Int)
data class Vertex(val id: VertexId, val neighbours: Set<VertexId>)
data class Graph(val vertices: Set<Vertex>)

• Perl

my $G = Graph::Undirected->new(edges => [
    [1,3], [2,4], [3,4], [3,5], [4,5]
]);

• Python

class Vertex(set): pass
class Graph(defaultdict):
  def __init__(self, *paths):
    self.default_factory = Vertex
    for path in paths:
      self.make_path(path)

  def make_path(self, labels):
    for l1, l2 in zip(labels, labels[1:]):
      self[l1].add(l2)
      self[l2].add(l1)

G = Graph((0, 1, 2, 3), (1, 4, 2))

• Ruby

Vertex = Struct.new(:x, :y, :z)
Graph = Struct.new(:vertex, :neighbours)

v = Vertex.new(1, 2, 3)
neighbours = [ Vertex.new(2, 3, 4), Vertex.new(4, 5, 6) ]
graph = Graph.new(v, neighbours)