upl 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcfc0c63c88755686e526182cb7ec46e5d6c7781adfce9671e8f24bb254d023e
-  data.tar.gz: a366bb2532d7f3734b2d0b47854bf585c513509acdb0cc07882b313194efc476
+  metadata.gz: fa378221e9a155214e277debd0451dc3ee7f0aa16c35f71ed838151824371c56
+  data.tar.gz: ecf227095d069fdde0639b5e685f7e000cd272358daea498910eca648cfb42b5
 SHA512:
-  metadata.gz: ce81943acf58d09751d44c643d33e1efa3089e4921886ddfde30e5148e607b0cbde69bafc132c6d613b11b1066667535dcbc4c73842535674a2945dbc17963ae
-  data.tar.gz: 51a14597a059f3d24fd30a88eb7406386074768afbf67b0fc9f7533059477018181583a6b2d56c205acf3f82ef9e6b4963ba423d93bb7343f128982ff3daaf13
+  metadata.gz: e7f9508863c480a8597cd6b35e343429ca1b9afcf4751116b4ea1694d6b260da05067128eefae21bc8873f816a8f85a4da9bef128ff873f25fe16f8ad1e4a3ab
+  data.tar.gz: 5e319c993b59af76d23f29a52f8cb70dcdc22b33f5110cc96e5608aed214ff0fdff61068e97a1e6d2e04190350861cd2bb701ebf95f1af93a8bbe105eae8ce24

data/History.txt

@@ -1,3 +1,7 @@
+== 0.2.0
+* add Upl::Query class for nicer api
+* faster term parsing
+
 == 0.1.0
 * register ruby predicates with exception handling
 * Some DSL improvements

data/README.md

@@ -17,12 +17,12 @@ The query api always returns an ```Enumerable``` of all values which satisfy the
 Query a built-in predicate, with a full expression:
 
 ``` ruby
-[1] pry(main)> enum = Upl.query <<~prolog
+[1] pry(main)> q = Upl::Query.new <<~prolog
   member(K,[home,executable,shared_object_extension]),
   current_prolog_flag(K,V)
 prolog
-=> #<Enumerator: ...>
-[2] pry(main) enum.to_a
+=> #<Upl::Query...>
+[2] pry(main) q.to_a
 => [{:K=>:executable, :V=>:upl},
     {:K=>:home, :V=>:"/usr/lib64/swipl"},
     {:K=>:shared_object_extension, :V=>:so}]
@@ -79,12 +79,8 @@ Alician proportions. So, here we GOOOoooo...
 => person/3(john,anderson,#<Object:0x0000563346a08e38 @_upl_atom=439429>)
 [2] pry(main)> Upl.assertz fact
 => true
-[3] pry(main)> ha, = Array Upl.query 'person(A,B,C)'
-=> [{:A=>john,
-  :B=>anderson,
-  :C=>#<Object:0x0000563346a08e38 @_upl_atom=439429>}]
-[4] pry(main)> ha[:C].equal? o
-=> true
+[3] pry(main)> Upl::Query.new('person(A,B,C)').first[:C]
+=> #<Object:0x0000563346a08e38 @_upl_atom=439429>}]
 ```
 
 Woo. An object disappears into prolog, and comes back out again. Having gained
@@ -100,20 +96,20 @@ fact2 = Upl::Term :person, :thomas, :paine, (thing2 = Object.new)
 Upl.assertz fact2
 
 # Note that both facts are in the result and the values for C are different
-query_term, query_vars = Upl::Runtime.term_vars 'person(A,B,C)'
-Array Upl::Runtime.term_vars_query query_term, query_vars
+q = Upl::Query.new 'person(A,B,C)'
+q.to_a
 =>[
  {:A=>james,  :B=>madison, :C=>#<Object:0x0000563f56e35580 @_upl_atom=439429>},
  {:A=>thomas, :B=>paine,   :C=>#<Object:0x0000563f56d2b5b8 @_upl_atom=439813>}
 ]
 
 # Unify C with thing2
-query_term, query_vars = Upl::Runtime.term_vars 'person(A,B,C)'
-query_vars.C = thing2
+q = Upl::Query.new 'person(A,B,C)'
+q.C = thing2
 
 # ... and we get the correct result
 # Note that the first fact is not in the result.
-Array Upl::Runtime.term_vars_query query_term, query_vars
+q.first
 => [{:A=>thomas, :B=>paine, :C=>#<Object:0x0000563f56d2b5b8 @_upl_atom=439813>}]
 ```
 
@@ -125,9 +121,9 @@ def (obj = Object.new).voicemail
   "Hey. For your logs."
 end
 
-query_term, query_vars = Upl::Runtime.term_vars "mcall(O,voicemail,St),string_codes(St,Co)"
-query_vars.O = obj
-Array Upl::Runtime.term_vars_query query_term, query_vars
+q = Upl::Query.new "mcall(O,voicemail,St),string_codes(St,Co)"
+q.O = obj
+q.to_a
 => [{:O=>#<Object:0x00005610453b0528 @_upl_atom=495109>,
   :St=>"Hey. For your logs.",
   :Co=>[72, 101, 121, 46, 32, 70, 111, 114, 32, 121, 111, 117, 114, 32, 108, 111, 103, 115, 46]}]
@@ -142,7 +138,7 @@ Upl::Foreign.register_semidet :special_concat do |arg0, arg1|
   arg1 === "#{arg0}-special"
 end
 
-Array Upl.query 'special_concat(hello, A)'
+Upl::Query.new('special_concat(hello, A)').to_a
 => [{:A=>"hello-special"}]
 ```
 
@@ -169,8 +165,6 @@ You cannot talk to swipl from a Thread other than ```Thread::main```. See https:
 
 I've used it to drive an address DCG on 50,000 addresses. Memory usage was stable.
 
-You cannot talk to swipl from a Thread other than ```Thread::main```
-
 ruby has a GC. swipl has a GC. At some point they will disagree. I haven't reached that point yet.
 
 UTF8-passthrough is not implemented, but there's a good chance you'll get what you want with the help of ```String#force_encoding('UTF-8')```.

data/lib/upl.rb

@@ -12,8 +12,11 @@ require_relative 'upl/tree'
 require_relative 'upl/inter'
 require_relative 'upl/term_vector'
 require_relative 'upl/foreign'
+require_relative 'upl/query'
 
 module Upl
+  # todo need .call and .consult at this level?
+
   # an enumerator yielding hashes keyed by the variables, mapping to the term
   module_function def query string_or_term, vars = nil, &blk
     if string_or_term.is_a?(Term) && vars

data/lib/upl/dict.rb

@@ -14,7 +14,7 @@ module Upl
       # eg, need to check that args.size == predicate.arity
       # otherwise segfaults and other weird stuff ensue
       rv = Extern::PL_call_predicate \
-        Extern::NULL, # module
+        Fiddle::NULL, # module
         0, # flags, see PL_open_query
         (Runtime.predicate 'is_dict', args.size),
         args.terms

data/lib/upl/extern.rb

@@ -7,36 +7,41 @@ module Upl
   module Extern
     extend Fiddle::Importer
 
-    # use swipl config to find the .so file
-    def self.so_path
-      begin
-        swipl_exe = 'swipl'
-        values = `#{swipl_exe} --dump-runtime-variables=sh`.each_line.with_object Hash.new do |line,ha|
-          line.chomp!
-          # split by = and for rhs strip surrounding quotes and trailing ;
-          line =~ /^([^=]+)="([^"]*)";$/
-          ha[$1] = $2.strip
-        end
-      rescue Errno::ENOENT => ex
-        puts "#{swipl_exe} not found on path #{ENV['PATH']}"
-        exit 1
+    # fetch config values from swipl executable
+    def self.swipl_config_values
+      swipl_exe = 'swipl'
+      values = `#{swipl_exe} --dump-runtime-variables=sh`.each_line.with_object Hash.new do |line,ha|
+        # split by = and for rhs strip surrounding quotes and trailing ;
+        line =~ /^([^=]+)="([^"]*)";\s*$/
+        ha[$1] = $2.strip
       end
+    rescue Errno::ENOENT => ex
+      puts "#{swipl_exe} not found on path #{ENV['PATH']}"
+      exit 1
+    end
 
-      begin
-        # should result in something like
-        #   /usr/lib64/swipl-7.7.18/lib/x86_64-linux/libswipl.so
-        # which should actually exist
-        p = Pathname "#{values['PLBASE']}/lib/#{values['PLARCH']}/#{values['PLLIB'].gsub('-l', 'lib')}.#{values['PLSOEXT']}"
-        p.realpath.to_s
-      rescue Errno::ENOENT => ex
-        puts "problem with library #{p.to_s}: #{ex.message}"
-        exit 1
-      end
+    # use swipl config to find the .so file
+    # should result in something like
+    #   /usr/lib64/swipl-7.7.18/lib/x86_64-linux/libswipl.so
+    # which should actually exist
+    def self.so_path
+      values = swipl_config_values
+      p = Pathname "#{values['PLBASE']}/lib/#{values['PLARCH']}/#{values['PLLIB'].gsub('-l', 'lib')}.#{values['PLSOEXT']}"
+      p.realpath.to_s
+    rescue Errno::ENOENT => ex
+      puts "problem with library #{p.to_s}: #{ex.message}"
+      exit 1
     end
 
     dlload so_path
 
-    NULL = Fiddle::Pointer.new 0
+    def self.ruby_free_fn
+      @ruby_free_fn ||= Fiddle::Function.new Fiddle::RUBY_FREE, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOID
+    end
+
+    def self.swipl_free_fn
+      @swipl_free_fn ||= Fiddle::Function.new self['PL_free'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOID
+    end
 
     typealias 'term_t', 'void *'
     typealias 'module_t', 'void *'
@@ -145,9 +150,16 @@ module Upl
 
     extern 'int PL_register_foreign_in_module(char *mod, char *name, int arity, foreign_t (*f)(), int flags, ...)'
 
+    # /usr/lib64/swipl/include/SWI-Prolog.h
     module Convert
-      REP_UTF8  = 0x1000
-      BUF_MALLOC = 0x0200
+      BUF_DISCARDABLE = 0x0000
+      BUF_RING =        0x0100
+      BUF_MALLOC =      0x0200
+      BUF_ALLOW_STACK = 0x0400
+
+      REP_ISO_LATIN_1 = 0x0000
+      REP_UTF8  =       0x1000
+      REP_MB =          0x2000
 
       CVT_ATOM =            0x0001
       CVT_STRING =          0x0002
@@ -220,8 +232,9 @@ module Upl
     extern 'int PL_is_number(term_t t)'
     extern 'int PL_is_acyclic(term_t t)'
 
-    extern 'int PL_put_atom(term_t t, atom_t a)'
     extern 'int PL_put_variable(term_t t)'
+    extern 'int PL_put_atom(term_t t, atom_t a)'
+    extern 'int PL_put_chars(term_t t, int flags, size_t len, const char *chars)'
     extern 'int PL_put_functor(term_t t, functor_t functor)'
     extern 'int PL_put_term(term_t t1, term_t t2)' # Make t1 point to the same term as t2.
     extern 'int PL_put_integer(term_t t, long i)'
@@ -234,8 +247,7 @@ module Upl
     extern 'int PL_unify_arg(int index, term_t t, term_t a)' # set index-th arg of t to a
 
     extern 'int PL_get_atom_chars(term_t t, char **a)'
-    # TODO deprecated, use something else
-    extern 'int PL_get_string(term_t t, char **s, size_t *len)'
+    extern 'int PL_get_nchars(term_t t, size_t *len, char **s, unsigned int flags)'
     extern 'int PL_get_integer(term_t t, int *i)'
     extern 'int PL_get_int64(term_t t, int64_t *i)'
     extern 'int PL_get_float(term_t t, double *f)'
@@ -271,8 +283,7 @@ module Upl
     # PL_EXPORT(int)  PL_put_term_from_chars(term_t t, int flags, size_t len, const char *s);
     # extern 'int PL_put_term_from_chars(term_t t, int flags, size_t len, const char *s)'
 
-    extern 'int PL_chars_to_term(const char *chars, term_t term)'
-    extern 'int PL_wchars_to_term(const pl_wchar_t *chars, term_t term)'
+    extern 'int PL_put_term_from_chars(term_t t, int flags, size_t len, const char *s)'
 
     extern 'void PL_unregister_atom(atom_t a)'
 

data/lib/upl/inter.rb

@@ -138,6 +138,7 @@ protected
 end
 
 class Symbol
+  # TODO does this also need a to_term_t for atoms?
   def to_atom
     Upl::Extern.PL_new_atom to_s
   end
@@ -153,8 +154,16 @@ end
 
 class String
   def to_term_t
-    rv = Upl::Extern.PL_put_string_nchars (term_t = Upl::Extern.PL_new_term_ref), length, Fiddle::Pointer[self]
+    rv = Upl::Extern.PL_put_chars \
+      (term_t = Upl::Extern.PL_new_term_ref),
+      (Upl::Extern::PL_STRING | Upl::Extern::Convert::REP_UTF8),
+      # swipl PL_chars_t struct uses number of octets | or number of wide chars.
+      # So use bytesize of string here.
+      bytesize,
+      Fiddle::Pointer[self]
+
     rv == 1 or raise "can't convert #{self} to term"
+
     term_t
   end
 end

data/lib/upl/query.rb

@@ -0,0 +1,51 @@
+module Upl
+  # Mostly sugar
+  # TODO needs a row_proc like Sequel uses to generate the yielded values
+  # TODO maybe cache @count (after first enumeration)
+  class Query
+    # TODO can only be string at this point
+    # One-use only. If you want a new query, create another instance.
+    # Is an enumerable for the result set.
+    def initialize term_or_string
+      @source = term_or_string
+      @term, @vars = Upl::Runtime.term_vars term_or_string
+    end
+
+    attr_reader :source, :term, :vars
+
+    def names; @vars.keys end
+
+    def method_missing meth, *args, &blk
+      if meth.end_with? '='
+        assign = true
+        name = meth[..-2].to_sym
+      else
+        name = meth
+      end
+
+      return super unless @vars.include? name
+
+      if assign
+        @vars[name] === args.first or raise "Unification failure"
+      else
+        @vars[name]
+      end
+    end
+
+    def [] name; @vars[name] end
+
+    def []= name, value
+      @vars[name] === value or raise "Unification failure"
+    end
+
+    def call
+      @results ||= Upl::Runtime.term_vars_query @term, @vars
+    end
+
+    def each &blk
+      call.each &blk
+    end
+
+    include Enumerable
+  end
+end

data/lib/upl/runtime.rb

@@ -2,6 +2,7 @@ require 'fiddle'
 
 require_relative 'extern'
 
+# TODO move this to inter, or maybe a refinement
 class Fiddle::Pointer
   def term_type
     ::Upl::Extern.PL_term_type self
@@ -15,6 +16,7 @@ end
 
 module Upl
   module Runtime
+    # shortcuttery
     Ptr = Fiddle::Pointer
 
     class PrologException < RuntimeError
@@ -43,18 +45,10 @@ module Upl
         raise "dunno bout #{st_or_term}"
       end
 
-      rv = Extern.PL_call term.term_t, Extern::NULL
+      rv = Extern.PL_call term.term_t, Fiddle::NULL
       rv == 1 # don't raise
     end
 
-    def self.ruby_free_fn
-      @ruby_free_fn ||= Fiddle::Function.new Fiddle::RUBY_FREE, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOID
-    end
-
-    def self.swipl_free_fn
-      @swipl_free_fn ||= Fiddle::Function.new Extern['PL_free'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOID
-    end
-
     def self.init
       # set up no output so we don't get swipl command line interfering in ruby
       # TODO exception handling should not kick off a prolog terminal
@@ -62,8 +56,9 @@ module Upl
       args = %w[upl --tty=false --signals=false --debug=false --quiet=true]
 
       # convert args to char **
+      # TODO Fiddle::SIZEOF_VOIDP would be faster
       ptr_size = Extern.sizeof 'char*'
-      arg_ptrs = Ptr.malloc ptr_size * args.size, ruby_free_fn
+      arg_ptrs = Ptr.malloc ptr_size * args.size, Extern::ruby_free_fn
       args.each_with_index do |rg,i|
         (arg_ptrs + i*ptr_size)[0,ptr_size] = Ptr[rg].ref
       end
@@ -77,10 +72,13 @@ module Upl
     end
 
     # once_only. Should probably be a singleton or something.
+    # TODO Nope, wrong. init is for the entire engine.
+    # PL_thread_attach_engine is for one-to-one threads,
+    # PL_create_engine is for engine pool
     Thread::current[:upl] ||= init
 
-    def self.predicate name, arity, module_name = nil
-      Extern.PL_predicate Fiddle::Pointer[name.to_s], arity, NULL
+    def self.predicate name, arity, module_name = 0
+      Extern.PL_predicate Ptr[name.to_s], arity, Fiddle::Pointer[module_name]
     end
 
     def self.unify( term_a, term_b )
@@ -103,7 +101,7 @@ module Upl
     # remember Atom can also be a string for swipl
     def self.term_vars st
       rv = Extern::PL_call_predicate \
-        Extern::NULL, # module
+        Fiddle::NULL, # module
         0, # flags, see PL_open_query
         (predicate 'atom_to_term', 3),
         # 3 variables, first one determined
@@ -124,7 +122,7 @@ module Upl
     def self.open_query qterm, args, mod: nil, flags: nil, &blk
       # This will need a string for the module, eventually
       # module is NULL, flags is 0
-      mod ||= Extern::NULL
+      mod ||= Fiddle::NULL
       flags ||= flags=Extern::Flags::PL_Q_EXT_STATUS | Extern::Flags::PL_Q_CATCH_EXCEPTION
 
       query_id_p = Extern.PL_open_query mod, flags, qterm.to_predicate, args.terms
@@ -186,7 +184,7 @@ module Upl
     end
 
     def self.predicate name, arity
-      pred_p = Extern.PL_predicate Ptr[name.to_s], arity, Extern::NULL
+      pred_p = Extern.PL_predicate Ptr[name.to_s], arity, Fiddle::NULL
     end
 
     # Simple query with predicate / arity
@@ -201,7 +199,7 @@ module Upl
       qterm = Object.new
       qterm.define_singleton_method :to_predicate do
         p_functor = Extern::PL_new_functor predicate_str.to_sym.to_atom, arity
-        Extern::PL_pred p_functor, Extern::NULL
+        Extern::PL_pred p_functor, Fiddle::NULL
       end
 
       args = TermVector.new arity

data/lib/upl/term.rb

@@ -5,9 +5,20 @@ module Upl
     def initialize term_or_string
       case term_or_string
       when String
-        @term_t = Extern.PL_new_term_ref
-        rv = Extern.PL_chars_to_term Fiddle::Pointer[term_or_string], @term_t
-        rv == 1 or raise "failure parsing term #{term_or_string}"
+        # sadly, this doesn't keep variable names
+        rv = Extern.PL_put_term_from_chars \
+          (@term_t = Extern.PL_new_term_ref),
+          Extern::Convert::REP_UTF8,
+          term_or_string.bytesize,
+          Fiddle::Pointer[term_or_string]
+
+        case rv
+        when 1; true # all ok
+        when 0
+          raise "failure parsing term #{term_or_string}, #{Tree.of_term(@term_t).inspect}"
+        else
+          raise "unknown api return value #{rv}"
+        end
 
       when Fiddle::Pointer
         # assume this is a pointer to a term. Unsafe, but there's no choice really
@@ -45,10 +56,11 @@ module Upl
     end
 
     def populate
-      int_ptr = Runtime::Ptr[0].ref
-      atom_ptr = Runtime::Ptr[0].ref
+      rv = Extern::PL_get_name_arity \
+        term_t,
+        (atom_ptr = Fiddle::Pointer[0].ref),
+        (int_ptr = Fiddle::Pointer[0].ref)
 
-      rv = Extern::PL_get_name_arity term_t, atom_ptr, int_ptr
       # This happens when the term_t is not a PL_TERM (ie a compound)
       rv == 1 or raise "can't populate term"
 
@@ -85,7 +97,7 @@ module Upl
     end
 
     def to_predicate
-      Extern::PL_pred to_functor, Extern::NULL
+      Extern::PL_pred to_functor, Fiddle::NULL
     end
 
     def tree; @tree || (Tree.of_term term_t) end
@@ -106,6 +118,10 @@ module Upl
     def first; self[0] end
     def last; self[arity-1] end
 
+    def deconstruct
+      map{|t| Term.new t}
+    end
+
     def [](idx)
       # remember args for terms are 1-based
       rv = Extern::PL_get_arg idx+1, term_t, (arg = Extern.PL_new_term_ref)

data/lib/upl/tree.rb

@@ -5,6 +5,7 @@ module Upl
   # queries give back their results as terms which are invalidated as soon as
   # the next set of results is calculated. So we need to turn those terms into a
   # ruby representation and keep them around.
+  # TODO rename to Ast
   class Tree
     # term is either a Term instance, or a Fiddle::Pointer to a term_t
     def initialize( term )
@@ -53,9 +54,20 @@ module Upl
         bytes.unpack('D').first
 
       when Extern::PL_STRING
-        rv = Extern.PL_get_string term_t, (str_ptr = Fiddle::Pointer[0].ref), (len_ptr = Fiddle::Pointer[0].ref)
-        value_ptr = Fiddle::Pointer.new str_ptr.ptr, len_ptr.ptr.to_i
-        value_ptr.to_s[0,len_ptr.ptr.to_i]
+        # TODO could possibly get away with BUF_DISCARDABLE here?
+
+        flag_mod = Upl::Extern::Convert
+        rv = Extern.PL_get_nchars \
+          term_t,
+          (len_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Extern::ruby_free_fn)),
+          (str_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Extern::ruby_free_fn)),
+          flag_mod::CVT_STRING | flag_mod::BUF_MALLOC | flag_mod::REP_UTF8
+
+        # note that length here is number of octets, not number of utf8 chars
+        string = String.new (str_ptr.ptr.to_s len_ptr.ptr.to_i), encoding: Encoding::UTF_8
+        # eventually free the malloc'd memory for the string
+        str_ptr.ptr.free = Extern::swipl_free_fn
+        string
 
       when Extern::PL_NIL
         # TODO maybe this should be [] - see what happens when term_vars has no vars
@@ -79,6 +91,18 @@ module Upl
 
     def arity; args.size end
 
+    # for 2.7 case ... in pattern matching
+    # for case term; in functor,arg1,arg; arg1
+    def deconstruct
+      [atom, *args]
+    end
+
+    def inspect
+      pp = PP.new
+      pretty_print pp
+      pp.output
+    end
+
     def pretty_print(pp)
       unless atom.to_sym == :','
         pp.text atom.to_s

data/lib/upl/variable.rb

@@ -31,6 +31,7 @@ module Upl
 
     def === value; unify value end
 
+    # TODO remove
     # bit of a hack to create empty variables for a functor
     def self.to_term
       Extern.PL_new_term_ref
@@ -47,13 +48,14 @@ module Upl
       @_string ||= begin
         rv = Extern::PL_get_chars \
           term_t,
-          (str_ref = Runtime::Ptr[0].ref),
+          (str_ref = Fiddle::Pointer[0].ref),
           # need cvt_variable for normal variables, and cvt_write for clpfd variables
           Extern::Convert::CVT_VARIABLE | Extern::Convert::CVT_WRITE | Extern::Convert::REP_UTF8 | Extern::Convert::BUF_MALLOC
           # | Extern::CVT_ALL
 
-        str_ref.ptr.free = Runtime.swipl_free_fn
+        str_ref.ptr.free = Extern::swipl_free_fn
         # TODO might need to force utf8 encoding here?
+        # Just use CVT_UTF8
         str_ref.ptr.to_s
       end
     end

data/lib/upl/version.rb

@@ -1,3 +1,3 @@
 module Upl
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: upl
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - John Anderson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-11 00:00:00.000000000 Z
+date: 2020-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,6 +104,7 @@ files:
 - lib/upl/foreign.rb
 - lib/upl/functor.rb
 - lib/upl/inter.rb
+- lib/upl/query.rb
 - lib/upl/runtime.rb
 - lib/upl/term.rb
 - lib/upl/term_vector.rb
@@ -111,7 +112,6 @@ files:
 - lib/upl/variable.rb
 - lib/upl/variables.rb
 - lib/upl/version.rb
-- scratch/register_predicate.rb
 - upl.gemspec
 homepage: https://github.com/djellemah/upl
 licenses:

data/scratch/register_predicate.rb

@@ -1,9 +0,0 @@
-def doit
-  fact = Upl::Term :person, :john, :anderson, Object.new
-  Upl.assertz fact
-  vs = Array Upl.query 'person(A,B,C)'
-  p vs
-  1000.times{Array Upl.query 'current_prolog_flag(K,V)'}
-  Upl.retract fact
-  Upl::Runtime.call Upl::Term :garbage_collect_atoms
-end