A cyclic graph

// Directed graph with linked adjacency lists; no array/list library is needed.
// Two connections create a cycle between vertices. neighbor_count counts only
// outgoing neighbors; it is not a graph traversal or reachability algorithm.
class Vertex {
    public let id: Int64
    public var edges: Edge?

    fn connect(target: Vertex) {
        edges = Edge(target: target, next: edges)
    }

    fn neighbor_count() {
        var count = 0
        var cursor = edges
        while cursor != null {
            let edge = cursor.unwrap()
            count = count + 1
            cursor = edge.next
        }
        return count
    }
}

class Edge {
    public let target: Vertex
    public var next: Edge?
}

let first = Vertex(id: 10, edges: null)
let second = Vertex(id: 20, edges: null)
first.connect(second)
second.connect(first)
print("First outgoing neighbors")
print(first.neighbor_count())
print("Second outgoing neighbors")
print(second.neighbor_count())
print("First edge reaches second vertex")
print(first.edges.unwrap().target == second)
print("Return edge reaches first vertex")
print(second.edges.unwrap().target == first)