M3/heisenbug

src/base_fixes.jl

@@ -11,3 +11,8 @@ function Base.func_for_method(m::Method, tt, env)
  end
 end
 println(" endof ok-warning.")
+
+
+# eltype for dicts
+Base.eltype{K}(::Type{Associative{K}}) = (K,Any)
+Base.eltype(::Type{Associative}) = (Any,Any)

src/commontraits.jl

@@ -56,19 +56,19 @@ end
 
 @traitdef Assoc{X} <: Indexable{X} begin
  K,V = eltype(X) 
- 
+
  # note, ObjectId dict is not part of this interface
- haskey(X, All)
- get(X, All, All)
- get(Function, X, All)
- get!(X, All, All)
- get!(Function, X, All)
- getkey(X, All, All)
- delete!(X, All) -> X
- pop!(X, All)
- pop!(X, All, All)
- merge(X, All...) -> X
- merge!(X, All...)
+ haskey(X, Any)
+ get(X, Any, Any)
+ get(Function, X, Any)
+ get!(X, Any, Any)
+ get!(Function, X, Any)
+ getkey(X, Any, Any)
+ delete!(X, Any) -> X
+ pop!(X, Any)
+ pop!(X, Any, Any)
+ # merge(X, Any...) -> X
+ # merge!(X, Any...)
  # provieds
  # keys(X) -> Base.KeyIterator
  # values(X) -> Base.ValueIterator

src/traitdef.jl

@@ -6,6 +6,7 @@
 #
 # It looks like
 # @traitdef Cmp{X,Y} <: Eq{X,Y} begin
+# T = eltype(X) # associated type
 # isless(x,y) -> Bool
 # @constraints begin
 # X==Y
@@ -95,7 +96,7 @@ function parsebody(body::Expr)
  isassoc(ex::Expr) = ex.head==:(=) # associated types
  isconstraints(ex::Expr) = ex.head==:macrocall # constraints
 
- outfns = Expr(:dict)
+ outfns = :(Traits.FDict())
  constr = :(Bool[])
  assoc = quote end
  for ln in Lines(body)
@@ -132,49 +133,60 @@ function parseconstraints!(constr, block)
 end
 
 function parsefnstypes!(outfns, ln)
+ # parse one line containing a function definition
  function parsefn(def)
  # Parse to get function signature.
  # parses f(X,Y), f{X <:T}(X,Y) and X+Y
- tvars = Any[]
- if isa(def.args[1], Symbol) # f(X,Y)
+ # into f and _f(...)
+
+ # getsymbol = gensym
+ getsymbol(fn) = symbol("__"*string(fn))
+
+ _fn = deepcopy(def)
+ if isa(def.args[1], Symbol) # f(X,Y) or X+Y
  fn = def.args[1]
+ _fn.args[1] = getsymbol(fn)
  elseif def.args[1].head==:curly # f{X}(X,Y)
  fn = def.args[1].args[1]
- # get
- tvars = def.args[1].args[2:end]
+ _fn.args[1].args[1] = getsymbol(fn)
  else
  throw(TraitException(
-  "Something went wrong parsing the trait definition body with line:\n$ln"))
+ "Something went wrong parsing the trait function definition:\n$fn"))
  end
- argtype = :()
- append!(argtype.args, def.args[2:end])
- return fn, argtype, tvars
+ # transform X->::X
+ for i=2:length(_fn.args)
+ @show _fn.args[i]
+ _fn.args[i] = :(::$(_fn.args[i]))
+ end
+ @show fn, _fn
+ return fn, _fn
  end
  function parseret!(rettype, ln)
  # parse to get return types
  while ln.head!=:block
  ln = ln.args[end]
  end
  tmp = rettype.args
- rettype.args = Any[]
- push!(rettype.args, ln.args[end])
+ rettype.args = Any[] # per-pend
+ push!(rettype.args, :($(ln.args[end])())) # e.g. Bool(), the () is for return_types to work
  append!(rettype.args, tmp)
  end
-
 
  rettype = :()
  tuplereturn = false
  if ln.head==:tuple
  tuplereturn = true
  # several ret-types:
  # f1(X,Y) -> X,Y
- append!(rettype.args, ln.args[2:end])
+ for r in ln.args[2:end]
+ push!(rettype.args, :($r()))
+ end
  ln = ln.args[1]
  end
 
  if ln.head==:(->) # f1(X,Y) -> x
  parseret!(rettype, ln)
- fn, argtype, tvars = parsefn(ln.args[1])
+ fn, _fn = parsefn(ln.args[1])
  elseif ln.head==:call # either f1(X,Y) or X + Y -> Z
  if isa(ln.args[end], Expr) && ln.args[end].head==:(->) # X + Y -> Z
  def = Expr(:call)
@@ -187,37 +199,22 @@ function parsefnstypes!(outfns, ln)
  parseret!(rettype, ln)
  else # f1(X,Y)
  def = ln
- rettype = :(Any,)
+ rettype = :(Any(),)
  end
- fn, argtype, tvars = parsefn(def)
+ fn, _fn = parsefn(def)
  else
  throw(TraitException(
  "Something went wrong parsing the trait definition body with line:\n$ln"))
  end
- # replace types with constraints by TypeVars
- tmp = Any[]
- for t in tvars
- if isa(t,Symbol)
- #error("Having a ")
- push!(tmp,t)
- else
- push!(tmp,t.args[1])
- end
- end
- # trans = Dict(zip([t.args[1] for t in tvars], tvars)) # this will error if there is a type-var without constraints!
- trans = Dict(zip(tmp,tvars))
- translate!(argtype.args, trans)
- tvar2tvar!(argtype.args)
- subt2tvar!(rettype.args)
- translate!(rettype.args, trans)
- tvar2tvar!(rettype.args)
 
  # if return is not a tuple, ditch the tuple
  if !tuplereturn
  rettype = rettype.args[1]
  end
 
- push!(outfns.args, :($fn => ($argtype, $rettype)))
+ # make _fn
+ _fn = :($_fn = $rettype)
+ push!(outfns.args, :($fn => $_fn))
 end
 
 # 3) piece it together
@@ -274,7 +271,7 @@ macro traitdef(head, body)
  # make sure a generic function of all associated types exisits
 
  traitbody = quote
- methods::Dict{Union(Function,DataType), Tuple}
+ methods::Traits.FDict
  constraints::Vector{Bool}
  assoctyps::Vector{Any}
  function $((name))()