feat(): meta specification language

Author: bvdmitri

src/GraphPPL.jl

@@ -9,5 +9,6 @@ __get_current_backend() = ReactiveMPBackend()
 include("utils.jl")
 include("model.jl")
 include("constraints.jl")
+include("meta.jl")
 
 end # module

src/backends/reactivemp.jl

@@ -206,4 +206,14 @@ end
 
 function write_form_constraint_specification(::ReactiveMPBackend, T, args, kwargs) 
     return :(ReactiveMP.FormConstraintsSpecification($T, $args, $kwargs)) 
+end
+
+## Meta specification language
+
+function write_meta_specification(::ReactiveMPBackend, entries) 
+    return :(ReactiveMP.MetaSpecification($entries))
+end
+
+function write_meta_specification_entry(::ReactiveMPBackend, F, N, meta) 
+    return :(ReactiveMP.MetaSpecificationEntry(Val($F), Val($N), $meta))
 end

src/constraints.jl

@@ -56,7 +56,7 @@ end
 
 ## Factorisation constraints
 
-struct FactorisationConstraintLHSMeta
+struct FactorisationConstraintLHSInfo
     name :: String
     hash :: UInt
     varname :: Symbol
@@ -134,7 +134,7 @@ function generate_constraints_expression(backend, constraints_specification)
     cs_args   = cs_args === nothing ? [] : cs_args
     cs_kwargs = cs_kwargs === nothing ? [] : cs_kwargs
 
-    lhs_dict = Dict{UInt, FactorisationConstraintLHSMeta}()
+    lhs_dict = Dict{UInt, FactorisationConstraintLHSInfo}()
 
     marginals_form_constraints_symbol      = gensym(:marginals_form_constraint)
     marginals_form_constraints_symbol_init = :($marginals_form_constraints_symbol = (;))
@@ -223,17 +223,17 @@ function generate_constraints_expression(backend, constraints_specification)
             (lhs_names == rhs_names) || error("LHS and RHS of the $(expression) expression has different set of variables.")
 
             lhs_hash = hash(lhs)
-            lhs_meta = if haskey(lhs_dict, lhs_hash)
+            lhs_info = if haskey(lhs_dict, lhs_hash)
                 lhs_dict[ lhs_hash ]
             else
                 lhs_name = string("q(", join(names, ", "), ")")
                 lhs_varname = gensym(lhs_name)
-                lhs_meta = FactorisationConstraintLHSMeta(lhs_name, lhs_hash, lhs_varname)
-                lhs_dict[lhs_hash] = lhs_meta
+                lhs_info = FactorisationConstraintLHSInfo(lhs_name, lhs_hash, lhs_varname)
+                lhs_dict[lhs_hash] = lhs_info
             end
 
-            lhs_name = lhs_meta.name
-            lhs_varname = lhs_meta.varname
+            lhs_name = lhs_info.name
+            lhs_varname = lhs_info.varname
 
             new_factorisation_specification = write_factorisation_constraint(backend, :(Val(($(map(QuoteNode, names)...),))), :(Val($(rhs))))
             check_is_not_defined            = write_check_factorisation_is_not_defined(backend, lhs_varname)
@@ -251,9 +251,9 @@ function generate_constraints_expression(backend, constraints_specification)
 
     # This block write initial variables for factorisation specification
     cs_lhs_init_block = map(collect(lhs_dict)) do pair
-        lhs_meta = last(pair)
-        lhs_name = lhs_meta.name
-        lhs_varname = lhs_meta.varname
+        lhs_info = last(pair)
+        lhs_name = lhs_info.name
+        lhs_varname = lhs_info.varname
         lhs_symbol = Symbol(lhs_name)
         return write_init_factorisation_not_defined(backend, lhs_varname, lhs_symbol)
     end

src/meta.jl

@@ -0,0 +1,91 @@
+export @meta
+
+"""
+    write_meta_specification(backend, entries)
+"""
+function write_meta_specification end
+
+"""
+    write_meta_specification_entry(backend, F, N, meta)
+"""
+function write_meta_specification_entry end
+
+macro meta(meta_specification)
+    return generate_meta_expression(__get_current_backend(), meta_specification)
+end
+
+struct MetaSpecificationLHSInfo
+    hash      :: UInt
+    checkname :: Symbol
+end
+
+function generate_meta_expression(backend, meta_specification)
+
+    if isblock(meta_specification)
+        generatedfname = gensym(:constraints)
+        generatedfbody = :(function $(generatedfname)() $meta_specification end)
+        return :($(generate_meta_expression(backend, generatedfbody))())
+    end
+
+    @capture(meta_specification, (function cs_name_(cs_args__; cs_kwargs__) cs_body_ end) | (function cs_name_(cs_args__) cs_body_ end)) || 
+        error("Meta specification language requires full function definition")
+    
+    cs_args   = cs_args === nothing ? [] : cs_args
+    cs_kwargs = cs_kwargs === nothing ? [] : cs_kwargs
+
+    lhs_dict = Dict{UInt, MetaSpecificationLHSInfo}()
+
+    meta_spec_symbol      = gensym(:meta)
+    meta_spec_symbol_init = :($meta_spec_symbol = ())
+
+    cs_body = postwalk(cs_body) do expression 
+        if @capture(expression, f_(args__) = meta_)
+
+            if !issymbol(f) || any(a -> !issymbol(a), args)
+                error("Invalid meta specification $(expression)")
+            end
+
+            lhs      = :($f($(args...)))
+            lhs_hash = hash(lhs)
+            lhs_info = if haskey(lhs_dict, lhs_hash)
+                lhs_dict[ lhs_hash ]
+            else
+                lhs_checkname = gensym(f)
+                lhs_info      = MetaSpecificationLHSInfo(lhs_hash, lhs_checkname)
+                lhs_dict[lhs_hash] = lhs_info
+            end
+
+            lhs_checkname = lhs_info.checkname
+            error_msg     = "Meta specification $lhs has been redefined"
+            meta_entry    = write_meta_specification_entry(backend, QuoteNode(f), :(($(map(QuoteNode, args)...), )), meta)
+
+            return quote
+                ($lhs_checkname) && error($error_msg)
+                $meta_spec_symbol = ($meta_spec_symbol..., $meta_entry)
+                $lhs_checkname = true
+            end
+        end
+        return expression
+    end
+
+    lhs_checknames_init = map(collect(pairs(lhs_dict))) do pair
+        lhs_info = last(pair)
+        lhs_checkname = lhs_info.checkname
+        return quote 
+            $lhs_checkname = false
+        end
+    end
+
+    ret_meta_specification = write_meta_specification(backend, meta_spec_symbol)
+
+    res = quote
+        function $cs_name($(cs_args...); $(cs_kwargs...))
+            $meta_spec_symbol_init
+            $(lhs_checknames_init...)
+            $cs_body
+            $ret_meta_specification
+        end 
+    end
+
+    return esc(res)
+end

src/utils.jl

@@ -1,4 +1,6 @@
 
+issymbol(::Symbol) = true
+issymbol(any)      = false
 
 isexpr(expr::Expr) = true
 isexpr(expr)       = false

test/utils.jl

@@ -3,6 +3,17 @@ module UtilsTests
 using Test
 using GraphPPL
 
+@testset "issymbol tests" begin
+    import GraphPPL: issymbol
+
+    @test issymbol(:(f(1))) === false
+    @test issymbol(:(f(1))) === false
+    @test issymbol(:(if true 1 else 2 end)) === false
+    @test issymbol(:hello) === true
+    @test issymbol(:a) === true
+    @test issymbol(123) === false
+end
+
 @testset "isexpr tests" begin
     import GraphPPL: isexpr