struct Fixed{N} <: EdgeModifier
    value::N
end
fixed(args...) = Fixed(args)

@StenoGraph begin
  f1  → fixed(1.0, NaN)*x1
end

julia> @StenoGraph a^Label("A") → b^Label("B")
a → b^Label("B") # where the fuck is `Label("A")`?

graph = @StenoGraph begin
    [x1, x2, x3] ⇔ [x1, x2, x3]
end

x1 ↔ x1
x1 ↔ x2
x1 ↔ x3
x2 ↔ x1
x2 ↔ x2
x2 ↔ x3
x3 ↔ x1
x3 ↔ x2
x3 ↔ x3

graph = @StenoGraph begin
    [x1, x2, x3] ⇔ [x1, x2, x3]
end

x1 ↔ x1
x1 ↔ x2
x1 ↔ x3
x2 ↔ x2
x2 ↔ x3
x3 ↔ x3

using StenoGraphs

graph_1 = StenoGraphs.@StenoGraph begin
    # latent regressions
    fac1 → fac2
end

struct NodeLabel_2 <: NodeModifier
    l
end
graph_2 = StenoGraphs.@StenoGraph begin
    # latent regressions
    fac1 → fac2^NodeLabel_2("Home an der Spree")
end

# These two graphs have slightly different types:
typeof(graph_1)
typeof(graph_2)

# When putting them into a vector, the Vector gets the type `Vector{Vector}`:
[graph_1, graph_2]

struct Edge
    src
    dst
end

struct Arrow
    edges
    lhs
    rhs
end


Edges(lhs, rhs) = [Edge(lhs, rhs)]
Edges(lhs::VecOrMat, rhs::VecOrMat) = Edge.(lhs, rhs)
Edges(lhs, rhs::VecOrMat) = Edge.(Ref(lhs), rhs)
Edges(lhs::VecOrMat, rhs) = Edge.(lhs, Ref(rhs))

Arrow(lhs, rhs) = Arrow(Edges(lhs, rhs), lhs, rhs)

test = Arrow([1; 2; 3], [4; 5; 6])

emptyvec(x::Vector{Eltype}) where Eltype = Vector{Eltype}()
Base.iterate(A::Arrow, state=1) = state > length(A.edges) ? nothing : (Arrow(emptyvec(A.edges), A.lhs[state], A.rhs[state]), state + 1)

for a in test
    println(a)
end

Base.getindex(A::ArrayAndChar{T,N}, inds::Vararg{Int,N}) where {T,N} = A.data[inds...]
Base.setindex!(A::ArrayAndChar{T,N}, val, inds::Vararg{Int,N}) where {T,N} = A.data[inds...] = val
Base.showarg(io::IO, A::ArrayAndChar, toplevel) = print(io, typeof(A), " with char '", A.char, "'")
Base.BroadcastStyle(::Type{<:ArrayAndChar}) = Broadcast.Style{MyType}()

struct MyStyle <: Broadcast.BroadcastStyle end
Base.BroadcastStyle(::Type{<:ArrayAndChar}) = MyStyle()

function Base.similar(bc::Broadcast.Broadcasted{Broadcast.Style{ArrayAndChar}}, ::Type{ElType}) where ElType
    # Scan the inputs for the ArrayAndChar:
    A = find_aac(bc)
    # Use the char field of A to create the output
    ArrayAndChar(similar(Array{ElType}, axes(bc)), A.char)
end

"`A = find_aac(As)` returns the last (!) ArrayAndChar among the arguments."
find_aac(bc::Base.Broadcast.Broadcasted) = find_aac(bc.args)
find_aac(args::Tuple) = find_aac(args[1], find_aac(Base.tail(args)))
find_aac(x) = x
find_aac(::Tuple{}) = nothing
find_aac(::Any, a::ArrayAndChar) = a
find_aac(::Any, rest) = find_aac(rest)

a = ArrayAndChar([1 2; 3 4], 'x')
b = ArrayAndChar([1 1; 1 1], 'b')
c = ArrayAndChar([2 2; 2 2], 'c')
a .+ 1
length
@run a .+ b .+ c

@run 1 .+ 2 .+ c