...possibly offensive to some. i wanted a nice syntax for people to define polynomials. the code below lets you write things like
2X^2 + 3X + 1 X+1 and packages the coefficients into a nice format for a constructor (an array of (coeff, power)). this kind of thing is common in haskell where because of the lovely syntax you can "hide" function application in expressions. i haven't seen anything similar in julia, but i haven;t read a lot of julia code. type Terms{I<:Integer} terms::Array{(I, Int)} end type Power exp::Int end type X end +{I<:Integer}(p1::Terms{I}, p2::Terms{I}) = Terms{I}(vcat(p1.terms, p2.terms )) +{I<:Integer}(::Type{X}, p2::Terms{I}) = Terms{I}(vcat([(one(I),1)], p2. terms)) +{I<:Integer}(p1::Terms{I}, ::Type{X}) = Terms{I}(vcat(p1.terms, [(one(I),1 )])) +{I<:Integer}(p1::Power, p2::Terms{I}) = Terms{I}(vcat([(one(I),p1.exp)], p2 .te\ rms)) +{I<:Integer}(p1::Terms{I}, p2::Power) = Terms{I}(vcat(p1.terms, [(one(I),p2 .ex\ p)])) +{I<:Integer}(n::I, p2::Terms{I}) = Terms{I}(vcat([(n,0)], p2.terms)) +{I<:Integer}(p1::Terms{I}, n::I) = Terms{I}(vcat(p1.terms, [(n,0)])) +{I<:Integer}(n::I, ::Type{X}) = Terms{I}([(n, 0),(one(I),1)]) +{I<:Integer}(::Type{X}, n::I) = Terms{I}([(one(I),1), (n, 0)]) ^(::Type{X}, exp::Int) = Power(exp) *{I<:Integer}(n::I, ::Type{X}) = Terms{I}([(n,1)]) *{I<:Integer}(n::I, p::Power) = Terms{I}([(n,p.exp)]) println(2X^2 + 3X + 1) println(X+1) which prints: Terms{Int64}([(2,2),(3,1),(1,0)]) Terms{Int64}([(1,1),(1,0)]) there are some issues. X alone, for example, doesn't have enough info to define the subtype of Integer, which i need. defining additional methods for that case to give a nice "syntax error" resulted in an explosion of ambiguous methods, so i dropped it an will try again later. also, you might hope to use promotion to avoid defining so much, but it turns out to be harder than i thought. anyway, i thought someone might find it amusing, andrew