Help making a literal function type

question

#1

So I’m working on a bit of a pet project which involves rolling my own computer algebra system. So far its really fun but I’m getting stuck with trying to define a special type of function called a literal_function. The idea with literal functions is to make a procedure that represents a function of one argument that has no known properties other than the given symbolic name.

Ie. I would like to be able to say

julia> f = literal_function(:f)
julia> f(:t)
:(f(t))

ie. a literal_function is constructed with a Symbol as its name and when given a symbolic input it just returns an expression that looks like
and unevaluated function call. This is easy to do, I did it simply with

function literal_function(name)
    function (t)
        :($name($t))
    end
end

However, I would like to be able to dispatch differently on literal_functions than I would with normal functions in certain circumstances, ie. I would like to have a type Literal_Function <: Function such that I can do some_other_function(f::Literal_Function) = stuff.

so I adapted some advice I got on Slack for another question I had and tried to make a type Literal_Function which does what I want.

struct Literal_Function <: Function end

function literal_function(name)
    function Literal_Function(t)
        :($name($t))
    end
end

but unfortunately the object this returns is not of type Literal_Function, its of type #Literal_Function#1{Symbol} .
Does anyone know how I can make my constructor literal_function return a function like object of type Literal_Function?


#2

Maybe something like this:

julia> struct LiteralFunction
           name::Symbol
       end

julia> x = LiteralFunction(:x)
LiteralFunction(:x)

julia> (f::LiteralFunction)(t) = :($(f.name)($t))    # **

julia> x(:t)
:(x(t))

Here LiteralFunction becomes a function-like object by defining how to call it in the line marked with **.


#3

I see, that’s a nice solution! thanks a bunch.