'Foo' has no method matching Foo(::Bar) - julia

Question

I'd like to start that I've not been able to recreate my problem in a stripped down version of the code. The code below works as intended, so this post is perhaps not well posed. The extended code, which is too long to post here, fails. I'll describe what I'm trying to do as maybe it'll help someone else out there.
I create three types: Bar, Baz, and Qux, which contains the method foo on Bar and Baz. I create a qux and query it's foo
qux = Wubble.Qux()
qux.foo
I get the following two methods, as expected:
foo(bar::Bar)
foo(baz::Baz)
Then when I try to actually use qux.foo with a bar or a baz, it gives me an error 'foo' has no method matching foo(::Bar).
Sadly, I can't recreate this error with stripped down code and the real code is unattractively long. What are the various ways of getting this error in this scenario that I've missed? It may be related to method extension and function shadowing like in this post, but I couldn't work a fix.
module Wibble
type Bar
data::Number
function Bar(num::Number=0)
this = new(num)
return this
end
end
end
module Wobble
type Baz
data::String
function Baz(vec::String="a")
this = new(vec)
return this
end
end
end
module Wubble
using Wibble
using Wobble
typealias Bar Wibble.Bar
typealias Baz Wobble.Baz
type Qux
foo::Function
function Methods(this::Qux)
function foo(bar::Bar)
println("foo with bar says ", bar.data)
end
function foo(baz::Baz)
println("foo with baz says ", baz.data)
end
this.foo = foo
return this
end
function Qux()
this = new()
this = Methods(this)
return this
end
end
end

Answer 1

I'm not really sure what's going wrong, but a couple of points which might help
You almost never want to have Function field in a type: this is a common idiomatic mistake made by people coming from "dot-based" OOP languages. Julia methods are generic, and don't belong to a particular type. There is no advantage to doing this, and not only is it more confusing (you have a lot of nested levels to write something that could be written in 2 lines), but it can make it harder for the compiler to reason about types, impacting performance.
You should use import Wibble.Bar instead of a typealias. If you use this, you don't need using.
Outer constructors are easier to use for specifying default arguments.
So in short, my version would be:
module Wibble
type Bar
data::Number
end
Bar() = Bar(0)
end
module Wobble
type Baz
data::String
end
Baz() = Baz("a")
end
module Wubble
import Wibble.Bar
import Wobble.Baz
qux(bar::Bar) = println("foo with bar says ", bar.data)
qux(baz::Baz) = println("foo with baz says ", baz.data)
end