)
```
Not sure if it works with your `TrialFunction` and `TestFunction` types, but you can try it.
You can then iterate over nodes to find variables of the type in question:
```julia
for nd in g
println(typeof(getvalue(nd)))
end
```
> [@ArjunNarayanan](#):
>
> ```julia
> @assemble ∇(v)[k]∇(u)[k]
>
> ```
>
> would give me
>
> ```julia
> K[I,J] = basis[I][k]*basis[J][k]
>
> ```
Expression `x[k] * y[k]` looks more like scalar product of vectors, even given type information it’s unclear whether it should be translated to:
```julia
K[i, j] = x[i, k] * y[k, j] # matrix multiplication
K[i, j] = x[i, k] * y[j, k]
K[i, j] = x[k, i] * y[k, j]
K[i] = x[k] * y[k] # summation over columns/rows
```
Usually exact meaning of operation in Einstein notation is defined by both - right-hand and left-hand side of an expression. This also makes it extremely hard to compose expressions with more than one operation on RHS.
Espresso.jl used to work with Einstein notation in versions up to v3.0.0 (search for `EinGraph`). Also [Einsum.jl](https://github.com/ahwillia/Einsum.jl) might be helpful, though both options are currently outdated and unmaintained.
---
### Author:  [@ArjunNarayanan](https://discourse.julialang.org/u/ArjunNarayanan)
#### Post date: [December 23, 2018, 5:04pm UTC](https://discourse.julialang.org/t/how-to-search-the-ast-for-specific-types-and-functions/18934/3 "2018-12-23T17:04:26Z")
Thanks for your reply.
> [@dfdx](#):
>
> (use `rewrite_all()` to apply the rule to all sub-expressions recursively; see also other utilities [here](https://github.com/dfdx/Espresso.jl/blob/master/src/rewrite.jl)).
Yes, that does seem to do what I want! I will check it out with a few examples.
> [@dfdx](#):
>
> Expression `x[k] * y[k]` looks more like scalar product of vectors, even given type information it’s unclear whether it should be translated to:
This was part of the reason why I decided to specify types for `TrialFunction` and `TestFunction`. After all the calculus operations like \nabla and div, the fields of my `TrialFunction` tell me the tensor rank (and how many derivatives to take for my basis function). Moreover, I figured it would be reasonable to expect the input equation to have exact summation notation form so there can be no ambiguity.
So if the user input has:
```julia
@assemble ∇(v)[k]∇(u)[k]
```
the user is implying that \nabla(v) is rank 1, and my code can ideally verify this by studying `typeof(∇(v))`.
Also, I figured that I wouldn’t bother trying to actually convert the index notation into code, but rather use the `@tensor` macro from the `TensorOperations` package for that purpose.
Which also raises another question: Can a macro return a macro?
Thanks for your time!
---
### Author:  [@stevengj](https://discourse.julialang.org/u/stevengj)
#### Post date: [December 24, 2018, 4:56am UTC](https://discourse.julialang.org/t/how-to-search-the-ast-for-specific-types-and-functions/18934/4 "2018-12-24T04:56:54Z")
> [@ArjunNarayanan](#):
>
> So if the user input has `@assemble ∇(v)[k]∇(u)[k]`
> the user is implying that `∇(v)` is rank 1, and my code can ideally verify this by studying `typeof(∇(v))` .
This is not possible in a macro. Macros only know how the expression is “spelled”, because they execute right after parsing — they don’t have any idea of what values symbols are bound to or what types they have.
If you need type information, then you need something that executes at runtime (or, in rare cases, at compile time via generated functions).
I don’t think you want macros at all, here. I think you maybe want a function like `assemble(∇(v)*∇(u))`, where `∇(v)` and `∇(u)` construct symbolic objects from test-function objects `v` and `u`, `*` multiplies them to construct another symbolic object, and `assemble` takes this symbolic structure and runs some computation on it to assemble your matrix.
(`@assemble ∇(v)[k]∇(u)[k]` would never work in any case because `∇(v)[k]∇(u)[k]` is not a valid parseable expression.)
---
### Author:  [@tkoolen](https://discourse.julialang.org/u/tkoolen)
#### Post date: [December 24, 2018, 5:25am UTC](https://discourse.julialang.org/t/how-to-search-the-ast-for-specific-types-and-functions/18934/5 "2018-12-24T05:25:32Z")
> [@stevengj](#):
>
> Macros only know how the expression is “spelled”, because they execute right after parsing — they don’t have any idea of what values symbols are bound to or what types they have.
This is key. Macros transform syntax into other syntax. You can however have a macro generate an expression that that contains a call to an overloaded function, so that the types of the values are involved in dispatch.
> [@stevengj](#):
>
> ( `@assemble ∇(v)[k]∇(u)[k]` would never work in any case because `∇(v)[k]∇(u)[k]` is not a valid parseable expression.)
You could circumvent this issue using a string macro, [Metaprogramming · The Julia Language](https://docs.julialang.org/en/v1/manual/metaprogramming/#Non-Standard-String-Literals-1). Not saying that’s necessarily a good idea, but maybe it’s an option.
If you’re feeling adventurous, you could also try experimenting with [GitHub - JuliaLabs/Cassette.jl: Overdub Your Julia Code](https://github.com/jrevels/Cassette.jl). Cassette allows you to essentially intercept and modify function calls that match specific signatures in a given user-defined context (in your case, say, the ‘assembly’ context). Again, not sure if it’s the right fit for this application though.
---
### Author:  [@ArjunNarayanan](https://discourse.julialang.org/u/ArjunNarayanan)
#### Post date: [December 24, 2018, 5:38am UTC](https://discourse.julialang.org/t/how-to-search-the-ast-for-specific-types-and-functions/18934/6 "2018-12-24T05:38:35Z")
I see. So a macro is a good idea if I am purely going to manipulate syntax. I suppose I could approach the problem from that angle too… I would just need to attach very specific meanings to the symbols I use in my expressions. However,
> [@stevengj](#):
>
> don’t think you want macros at all, here. I think you maybe want a function like `assemble(∇(v)*∇(u))` ,
I reckon this would be the more direct way for me.
Thanks for your inputs!
---
### Author:  [@chakravala](https://discourse.julialang.org/u/chakravala)
#### Post date: [December 24, 2018, 7:02am UTC](https://discourse.julialang.org/t/how-to-search-the-ast-for-specific-types-and-functions/18934/7 "2018-12-24T07:02:06Z")
> [@ArjunNarayanan](#):
>
> As a simple example, the ∇\nabla operator is linear, so if I encounter a call to `+` after a call to `∇` , then I can switch their order. How can I do such a thing in my AST?
> [@ArjunNarayanan](#):
>
> What is the most effective way of searching through the AST of my expression above looking for instances of my types?
Here is an example of a recursive function I made to search for and substitute certain types of numerical values and convert them to a specified type:
>
It can be used like this
```Julia
julia> SyntaxTree.sub(Float64,:(2x^2-1/2))
:(2.0 * x ^ 2 - 1.0 / 2.0)
```
You could do something similar for your requirements, so I would just write a custom recursive function which walks through your expression and checks for your relevant types and does whatever you need to do with it.
---
### Author:  [@ArjunNarayanan](https://discourse.julialang.org/u/ArjunNarayanan)
#### Post date: [December 25, 2018, 1:15am UTC](https://discourse.julialang.org/t/how-to-search-the-ast-for-specific-types-and-functions/18934/8 "2018-12-25T01:15:53Z")
This is really useful, especially the example recursive function. Thanks!