• Quite a few bug fixes.
• A revamped XML import package, which has now actually become useful. See examples at the Coherent Examples Bank
• A number of improvements in the \io system module. The behavior of the read* operations has been made uniform (even when the underlying Prolog primitives are not) and the signatures of these predicates has been changed to distinguish the input and output parameters.
• Expanded \parse package.
• Skolem constants can now be also named, not just numbered.
• System[type-> ?Type]@\sys now returns the type of the system on which Flora-2 currently runs.

Backward Incompatibility

• The changes in the XML package are incompatible with previous versions.
• Some method signatures in the \io module have changed.

General

This release adds several new features and fixes many bugs -- big and small.

News

• Many, many bug fixes.
• Better semantics for blocking non-monotonic behavioral inheritance via explicit negative information. See the section "Negative Non-monotonic Behavioral Non-Inheritance" in the manual.
• New option for setsemantics: setsemantics{inheritance=monotonic}. See the manual for further details.
• New argumentation theory, refute_clp, which is like the default argumentation theory, but the rebuttal conflict is ignored.
• User defined functions (UDFs) can now be queried like rules and latent queries via the clause{...} statement.
• New primitive counter{...} that facilitates creation/management of global counters. Counters are much more limited but also much cheaper substitutes for certain update operations.
• The datatype classes like \integer or \float are now truly logical so that ?X:\integer is undefined, but ?X^^\integer : \integer and 123 : \integer are true.
• New builtin meta-classes: \callable and \modular. The callable class has all the truth-valued literals and the moduler class has all the truth-valued literals that belong to some Flora-2 module.

Backward Incompatibility

• When a file is being loaded into (or added to) a module, the current directory is the directory of the file, not the directory where Flora-2 was started. This is a more logical behavior, but it might require some changes to multi-file knowledge bases. (This change stems in large part by a corresponding change in XSB.)

General

This is a primarily maintenance release with some new features and many small bug fixes.

News

• Many bug fixes.
• UTF-8 support.
• Interprolog updated.
• Incremental tabling is the default now.
• Simplified installation for Linux/Mac.
• A new shell command: feedback{on} and feedback{off}. This blocks the output of answers, Yes/No feedback to the user, etc. This is mostly used when Flora-2 is called from Java and other external languages.
• A new method, now, for the \date \time, and \dateTime data types.
• New shortcuts for checking list membership and sublist: the \in and \subset infix operators.
• A new \repeat option for \while-\do and \do-\until loops.
• New aggregate operators countdistinct, sumdistinct, avgdistinct.
• The constraint checker in the module \typecheck now understands the arguments of methods and does the right job for them.

Backward Incompatibility

• With the introduction of Unicode, some changes had to be made, which resulted in some backward inconsistency.
  • Unicode characters can be specified inside '...' (strings) and "..." (character lists) as \x or \u (or their capital letter counterparts) followed by 1 to 8 hexadecimal digits (0-F). This sequence must be terminated with a vertical bar, |.
  • Previously, hexadecimal symbols had the syntax \x followed by one or two hexadecimal digit. Now such sequences will not be accepted unless terminated with a |.
• In the olden days of Flora-2, an empty frame like abc[] was true only if the object abc was made somehow known to the knowledge base through another molecular statement like abc[foo->bar], foo:bar, or moo::foo. Then, due to the various additions, such empty frames became tautologically true - no matter what. Now the semantics has reverted to the original one. That is, abc[] is false unless it is mentioned in some frame formula as an object.
• Reactive (formerly: incremental) tabling is now the default. This means that it is no longer necessary to issue refresh commands unless nonincremental tabling is explicitly requested in some module. However, this switchover might cause some older programs to not run if they rely on non-logical update statements issued from under non-transactional (tabled) literals. In such cases, one must explicitly make those modules passively tabled (see the manual).
• Aggregate variables (i.e., aggr{AggrVar|...}) are now local to the respective aggregate statements. (The fact that they were global before was a long-standing bug.)
• It is now an error to invoke an aggregate with a ground grouping variable. For instance, in

  	  p(1).
  	  ?- p(?X),?Z=avg{?V[?X,?Y]|condition(?X,?Y,?V)}.
  	

  the aggregate operator will be invoked with ?X ground and this will cause a runtime error. A compile-time warning will also be issued. The manual has more on that.
• The \warnings(...) shell command is now warnings{...}, for consistency with others. Similarly, \chatter and \nochatter are now chatter{on} and chatter{off}. Related to this, is a new command: feedback{on} and feedback{off}. This controls whether Yes/No and query results are to be sent to the output. When Flora-2 runs under the control of a Java or a C program, it is more convenient to turn the feedback off.
• The options in the setsemantics directive and the semantics query primitive have changed from option(value) to the option=value format. For instance, setsemantics{equality=basic}.
• The character lists syntax "abc234" is now disabled by default because many users tend to not understand this data structure and misuse it. There is now a compiler option, called the expert mode in which this syntax is allowed. Otherwise, use "abc234"^^\charlist. See the new section The Expert Mode on the additional syntax that is permitted in the expert mode.
• In the Flora-Java API, queries that use builtin keywords like \and or \date have to be escaped with one backslash (e.g., \\and). Previously this API required quadrupling each backslash (e.g., \\\\and).
• The optimize{...} primitive has been removed. The option local_override used in that primitive has been deprecated, while the options subclassing and class_expressions are now part of the executable setsemantics{...} directive: setsemantics{subclassing=strict}, setsemantics{class_expressions=on}. The default for subclassing is strict, as before, but the default for class_expressions is now none, because this is what most users seem to expect.

General

This main feature of this release is the improved stability and implementation of the previously announced syntax changes aimed at simplifying the use of Flora-2 and aligning it with the Rulelog specification. The release also includes a number of bug fixes as well as a better implementation of the Lloyd-Topor transformation for first-order formulas in the rule bodies, a better integration of data types, and more.

News

• Typed variables can now range over classes, e.g., ?X^^MyClass. This should be used in preference to ?X:MyClass in most cases (see the manual).
• A more complete Lloyd-Topor transform.
• The new \show system module for getting printable representation of Flora-2 terms and subgoals.
• A much better integration of the data types.
• Better system stability.
• Major syntax changes, as described below.

The following major syntax changes have been implemented:

• Inheritable methods using *=>, *->, *->->, *+>>, etc.:

  These arrows have now been deprecated. Instead, there is now strict separation between the class information, which applies to all objects of a class, and object-level information, which applies to single objects. All these use the same arrows, =>, ->, etc, but class information now uses a different kind of brackets: [|...|]. Class and object-level information can no longer be mixed within the same frame formula.

  	  Old                            New
  	  obj[m*=>v]                     obj[|m=>v|]
  	  obj[m*->v]                     obj[|m->v|]
  	  obj[m*->->v]                   obj[|m->->v|]
  	  obj[m*+>>v]                    obj[|m+>>v|]
  	  obj[*m]                        obj[|m|]
  	  obj[*=>m]                      obj[|=>m|]
  	  obj[*=>%m]                     obj[|=>%m|]
  	

• Range cardinality constraints in signatures:

  Instead of Low:High use Low..High. For instance:

  	   Old                               New
  	   vehicle[wheels{1:8}=>_integer]    vehicle[wheels{1..8}=>\integer]
  	   vehicle[wheels{1:8}*=>_integer]   vehicle[|wheels{1..8}=>\integer|]
  	 

• Flora-2 no longer has alphanumeric reserved keywords! Every builtin feature now either requires a backslash, or it has been turned into a primitive that uses the curly braces {...} (as several directives did before), or they are used only as compiler directives and therefore do not affect the user space of predicate/function names. This de-reservation of keywords was made possible due to the syntax changes described below. Note that this does not affect the arithmetic functions, like mod, abs, which are used in conjunction with the is (now \is) operator-predicate, since these are functions, not predicates. Likewise, backslashes are not used for the old directives and primitives (like insert{...}, caller{...}), which were using curly braces.
• The builtin symbols that previously were prefixed with a '_' are now prefixed with the backslash or they now use curly braces. For instance:

  	  Old                            New
  	  _#                             \#
  	  _@                             \@
  	  _load                          \load      (for loading/adding Flora-2
  	  _compile                       \compile    from within Prolog)
  	  ...                            ...
  	  _load(foo)                     load{foo}  (for loading/adding Flora-2
  	  _add(foo)                      add{foo}    from within Flora-2)
  	  ...                            ...
  	  _isskolem(...)                 isskolem{...}
  	  _isinteger(...)                isinteger{...}
  	  _isground(...)                 isground{...}
  	  ...                            ...
  	 

• Loading commands for in-line files:

  	  Old                            New
  	  [_]                            []
  	  [+_]                           [+]
  	  [_>>module]                    [>>module]
  	  [+_>>module]                   [+>>module]
  	  _load(_)                       load{}
  	  _load(_>>module)               load{>>module}
  	  _add(_)                        add{}
  	  _add(_>>module)                add{>>module}
  	

• Truth-valued path expressions nested inside predicates and function terms have been shown to be too error-prone and are no longer allowed.

  	  Old                            New
  	  p(a[b->c])                     error
  	  p(a.d[b->c])                   error
  	  p(a.d.foo)                     allowed (a.d.foo is not truth-valued)
            p(a.d[b->c].foo)               allowed (a.d[b->c].foo is not truth-valued)
            p(a:b)                         allowed
            p(a::b)                        allowed
            p(a:b.c)                       allowed
            p(a.d::b.c)                    allowed
            p(a:b[c])                      error
            p(a::b[c])                     error
            p(a[d]:b)                      error
          

• All compiler directives that take arguments now require curly braces. Previously, different directives used different, non-uniform syntax, which ranged from parentheses, to prefix operators, to curly braces. For instance:

            Old                              New
            :- index foo/1, bar/2.           :- index{foo/1,bar/2}.
            :- iriprefix aaa=bbbb,ccc=dddd.  :- iriprefix{aaa=bbbb,ccc=dddd}.
            :- op(100,xfx,foobar).           :- op{100,xfx,foobar}.
            :- compiler_options([foo,bar]).  :- compiler_options{foo,bar}.
  	  :- export ... .                  :- export{...}.
  	  :- importmodule ... .            :- importmodule{...}.
  	  :- useudf ... .                  :- useudf{...}.
  	  :- usesensor ... .               :- usesensor{...}.
  	  :- defsensor(...).               :- defsensor{...}.
            etc.
           

• The builtin propositions as well as the operators used as predicates now require a backslash. Some were eliminated and some changed names.

  	  Old                                New
  	  naf                                \naf
  	  neg                                \neg
  	  is                                 \is
  	  if...then...else                   \if...\then...\else
  	  while...do                         \while...\do
  	  unless...do                        \unless...\do
  	  loop...until                       \loop...\until
  	  udf...if                           \udf...\if
  	  true                               \true
  	  false                              \false
  	  fail                               eliminated, use \false instead
  	  abolish_all_tables                 \abolishtables
  	  isa                                \isa
  	  memberOf                           \memberof
  	  subclassOf                         \sub, \subclassof
  	  hasValue                           \hasvalue
  	  hasType                            \hastype
  	 

• Note: the syntax for forall, exists, wish, must has not been changed, as these are not predicates.

General

Several new features, including two major extensions: set notation and first-order formulas in rule bodies.

News

• Set notation: it is now possible to use set notation virtually everywhere. Previously this was allowed only as the value part of methods, e.g., a[b->{c,d}]. Now it is possible to write things like p({1,2,3}) as a shorthand for p(1), p(2), p(3). Or ?X={?Y,?Z,abc} instead of ?X=?Y, ?Y=?Z, ?Y=abc. Or {a,b,c}:d. Even {p,q}({1,2}).
• Arbitrary first-order formulas are now possible in rule bodies, including universal quantifiers. This is done through the well-known Lloyd-Topor transformation to normal rules. The transform works with the quantifiers forall, exists, and the connectives naf, ~~>, if-then-else, and the like. This makes some complex rule much easier to write and makes this process less error-prone.
• Loading commands are now aware of the #include statements and recompile loaded files if any of the included files change.
• If the environment variable FLORA_RC_FILE is set and points to a readable initialization file, Flora-2 will read startup commands (any set of Flora-2 queries) from it.
• The previously existing primitives _isinteger/1, _isvar/1, _isground/1, etc., have now been documented. Also added their delayable 2-argument counterparts.

General

This version contains many bug fixes, some infrastructure improvements, and a small number of new features.

News

• The rule id is now a triple: (local-id, filename, module). The corresponding operations such as enable{...} and disable{...} have been updated.
• The new transactional enable/disable primitives: tenable{...} and tdisable{...}.
• A new feature: latent queries. This kind of queries can be seen as a cross between normal queries and rules.
• New quasi-constants: _@F: the file name where this constant occurs; _@L: the line number where this constant occurs; _@C: a substitute for caller{...} (the caller primitive hasn't been deprecated). These and other quasi-constants and quasi-variables are now summarized in a separate section in the manual.
• New builtin descriptor properties: file and module. Can be used to query the file and module components of rule Ids.
• Builtins operations on XML data types and others are much more memory-efficient now.

Backward Incompatibility

• The methods defined in the standard modules like _system, _io, _typecheck, and others no longer have the % in front of the methods. For example, Method[mustDefine(on)]@_sys instead of Method[%mustDefine(on)]@_sys.
• The methods defined in the module _basetype used to be prefixed with an underscore _. No longer. For instance, 123[toSymbol->?R]@_basetype rather than 123[_toSymbol->?R]@_basetype.
• In the future, we are planning to change the convention and replace the underscore _ in front of the various builtin constructs with the backslash \. For instance, \# instead of _#, \io instead of _io.
• Likewise in the future, we will eliminate the arrows *-> and *=>, as they cause much confusion. Instead, the class properties will be written using the [|...|] syntax while object properties will use the old [...] syntax. For instance, instead of abc[foo*->1,bar*=>_integer] we'll be using abc[|foo->1,bar=>\integer|]. It will no longer be possible to mix the class-level and object-level notation in the same F-molecule.

General

This version contains a number of bug fixes plus a new installation procedure.

News

• We have switched to bundled releases where the downloads contain both a suitable version of XSB and the latest release of Flora-2. One simple script now installs both and there is no need to install XSB separately. On Windows, a simple installer guides the installation, as usual for Windows programs.

  Users who download the latest versions of XSB and Flora-2 from their SVN repositories are unaffected by this new installation procedure.

• XSB and Flora-2 can now be installed in directories that have spaces in them.
• Evaluation of negation (naf) is now delayed automatically, if the subgoal has unbound variables. The delay takes place as long as there is still a possibility that those variables can be bound. This makes for a more logical treatment of negation.
• Inheritance can now be blocked via explicit negative information (manual, Section 16.2).

General

This version contains a number of bug fixes, performance enhancements, and various extensions.

News

This is a maintenance release that fixes several bugs and provides several minor enhancements.

• The compiled and the auxiliary files produced by Flora-2 are now in the .flora_aux_files subdirectory of the .flr file being compiled.
• =.. now works with complex reified statements such as if-then-else, update operators, negation, and others.
• UDFs can now be arbitrary HiLog terms, not necesarily of the form functor(args).
• Full support for rule descriptors, including the new syntax for querying them.
• Skolem symbold are now allowed in the rule bodies also outside of reifications and rule descriptors. An occurrence of a _# is interpreted as a test that that particular argument is bound to a skolem constant. An occurrence of a numbered Skolem, e.g. _#5, is interpreted the same except that multiple occurrences of the same numbered Skolem in the body of the same rule are interpreted as occurrences of the same Skolem.
• The auxiliary files generated by the compiler are now neatly stowed away in subdirectories called .flora_aux_files.
• The rarely used and unnecessary "package" install mode for Flora-2 has been eliminated.
• The restriction that Flora-2 cannot be installed in Windows folders whose paths contain spaces is believed to be gone for good.
• Greatly simplified installation for official releases. (Installation for SVN downloads and developers is unchanged.)
• Incompatible change: the keyword used to define user-defined functions has been changed from function to udf. Likewise, the directive usefunction has been changed to useudf.

General

This version contains many bug fixes, performance enhancements, and powerful extensions.

News

Flora-2 is now distributed under the Apache License 2.0.

The following new features have been added to Flora-2 in this release:

• Defeasible rules.
• Rule Ids and tags (for defeasible reasoning) can be specified.
• Explicit negation neg.
• User-defined functions.
• Delay quantifiers, which allow goal reordering at runtime.
• Hypothetical operators of Transaction Logic (possible <> and not possible ~<>).
• Incremental tabling is supported (subject to the limitations of XSB).
• Sensor predicates.
• Low-level predicates.
• Table dump and non-termination analysis utilities.

General

Flora-2 has undergone significant changes to make it more of a Web language. The system has also become more robust and many interfaces and enhancements were added. The syntax has been changed somewhat to make Flora-2 better aligned with other Semantic Web languages and, especially, with other F-logic based languages. This resulted in incompatible changes with respect to version 0.94 (see below; a special script is provided to simplify conversion of old programs to the new syntax).

News

• A new Java API
• A new Eclipse-based editor/visualizer.
• It is now possible to save the current state of a module in a file.
• Directive for importing one module into another.
• The meta-decomposition operator =.. now works not only for Prolog terms but also for HiLog terms and for reified formulas.
• It is now possible to specify the type (signature) of a Boolean method.
• Cardinality constraints can now be specified in class signatures. There are now standard methods for checking type and cardinality constraints. They are defined for classes Type and Cardinality, respectively, in the system module _typecheck.
• Structured primitive types, such as dateTime, time, IRI, etc.
• New syntax for compacr URIs to simplify specification of Web resources.
• New system library for reading and parsing terms from standard input, strings, and files.

Backward Incompatibility

Major incompatible changes of syntax: Some aspects of the syntax has been aligned with other rule languages for the Web and with F-logic based systems. There is a Perl script, convert.pl, in the Misc subdirectory, which can greatly simplify conversion of the old Flora-2 programs. The file Misc/README explains how to use this program.

• Variables now start with ? and uppercase alphanumeric atoms do not need to be quoted.
• Transactional methods are now designated with the prefix % instead of #.
• The equality(flogic) option in the setsemantics directive has been deprecated.
• The meaning of path expressions in the head of a rule has changed: they no longer create a new skolem term if the path expression does not have a value. Instead, the body of the rule is considered false in such a case.
• The @prolog() and @prolog(module) module specifications have been changed to @_prolog and @_prolog(module). To sweeten the pill, _plg instead of _prolog is also allowed. Likewise, @prologall() and @prologall(module) have become @_prologall and @_prologall(module), respectively, and the abbreviation _plgall is also accepted.
• The system module syntax @flora(module) has been changed to @_module. For instance, @flora(sys) is now @_sys.
• debug[%check_undefined(on)]@flora(sys) is now Method[%_mustDefine(on)]. The statement debug[%check_undefined(on,foomodule)]@flora(sys) is now Method[%_mustDefine(on(foomodule))], etc. The statement debug[%ignore_undefcheck(...)] is now Method[%_mustDefine(off,...).
• The builtins that start with fl, like flDemo, flEnd, etc., are now called _demo, _end, and the like. flImport is now '_flimport'.
• Pretty printing is now provided by a package rather than a system module. Invocation now differs slightly.
• In-place module, which allows the user to type a program at command line is now . (period) instead of the keyword user (i.e., one types [.] instead of [user]).

General

The development of Flora-2 has continued unabated. Apart from making the system more robust, we added a large number of enhancements. The syntax has also been cleaned up, which resulted in incompatible changes with respect to version 0.92 (see below).

News

• Modules can now be encapsulated. A module can export methods and predicates to all modules our to a particular list of predicates.
• One can now reify rules in addition to facts and other formulas.
• The new directives setsemantics{...} and semantics{...} allow the programmer set and query the semantics of any module.
• It is now possible to use "and" and "or" instead of "," and ";" when the latter mean conjunction and disjunction, respectively.
• A new predicate, flora_query, can now be used to send arbitrary queries to Flora-2 from the Prolog side. This means that one can use the XSB C or Java interfaces to send queries to Flora-2 through an intermediate Prolog module.
• The clause{...} primitive lets one query the rule base.
• The commands flAdd file and [+file] can now add contents to modules instead of erasing it. The command flCompileAdd is used to compile files for later loading into a module. It does not by itself load any files.
• Enhanced checking for undefined methods and predicates. The new directive #ignore_undefcheck allows to selectively relax checks for undefinedness in cases where such checks are undesirable.
• The following types are now predefined: integer, float, number, symbol, (a,b), (a;b), (a-b).
• There is now a rudimentary run-time optimizer, which the user can turn of and off dynamically. See flOptimize.
• Inheritance-less inheritance(none) semantics is now supported in addition to the usual semantics where inheritance is the default.
• Experimental support for persistent Flora-2 modules, which are stored in a database through the ODBC interface.
• Experimental support for XML/HTML/SGML parsing and XPath queries.

Backward Incompatibility

• Major incompatible change of syntax: HiLog predicates are now tabled by default. Non-tabled predicates must now be prefixed with a #, by analogy with non-tabled methods. The table directive has been deprecated.
• The symbol % is no longer starting a comment. Use /*...*/ and // instead. The symbol % will be reused for other purposes.
• The "equality" directive has been deprecated. Use the new setsemantics directive.
• Constructs like a[attr=> {b,c}] and a[attr=>> {b,c}] are no longer legal (i.e., the curly braces in the context of => or =>>). Use a[attr=> (b,c)] and a[attr=>> (b,c)] instead.
• Prolog predicates call/1 and findall/3 are no longer special in Flora-2 and should be avoided, since call/1 is redundant and findall/3 is superseded by the aggregate operators such as collectset{...}.

General

Flora-2 has undergone many changes and a great number of features were added. Some changes make the syntax of the present version incompatible with earlier versions. However, these changes simplify the language and improve its usability. It is the first version that is reasonably feature-complete and thus can be called a "beta".

News

• Major changes in the language: there are no firstorder predicates any more -- all are HiLog. See backward incompatibility.
• It is now possible to add new rules to the program at run time as well as create new program modules at run time. This is useful for agent programming. Typically one would use this feature by creating a new module and then adding rules to it at run time. Then calling the methods defined in that module.
• Inheritance is now implemented in accordance with the semantics defined in Well-Founded Optimism: Inheritance in Frame-Based Knowledge Bases. Intl. Conference on Ontologies, DataBases, and Applications of Semantics for Large Scale Information Systems (ODBASE), October, 2002. In plain terms it means that inheritance now "works right."
• It is now possible to call X@Module, where X and/or Module is a variable. This allows one to construct a term and then call it in a module or to query the modules in which a term is defined. For instance, the following will work: ..., p(X), X(a,Y), X@foo.
• Flora now honors XSB directives --nobanner, --noprompt, --quietload. This makes it easier to put graphical interfaces on top of Flora and simplifies interprogram communication.
• The update operators now also update the tabling information, which makes them much better behaved with queries. The new operator refresh{...} provides finer-grained control over cached queries.
• It is now possible to table HiLog predicates, but expect more changes to this syntax in future versions.
• Flora-2 now works under Cygwin. People might prefer this to the native Windows port, because it runs significantly faster.

Bugfixes

• There was a subtle bug in the behavior of multiple inheritance. This has now been fixed. Inheritance (and especially multiple inheritance) has now a well-defined model theoretic semantics, as described in Well-Founded Optimism: Inheritance in Frame-Based Knowledge Bases. Intl. Conference on Ontologies, DataBases, and Applications of Semantics for Large Scale Information Systems (ODBASE), October, 2002.
• Great many other small fixes.

Backward Incompatibility

• firstorder directive deprecated (all predicates are HiLog now)
• arguments directive deprecated (use the reification feature ${...} instead
• expunge deprecated
• flImport: syntax change, as we no longer need to specify firstorder/hilog
• index directive: change of syntax
• The calls flP2H, catch/3, throw/1 have been eliminated. Use the built-ins p2h{...,...}, catch{...,...,...}, and throw{...} instead.

General

This release introduces a number of new features, improves performance, and stability. The main highlights are the significantly faster compilation and improved support for reified statements. Some new features, such as the interface to CLPR constraint solving requires the latest version of XSB (from the CVS repository). It is also required, if you want to run Flora-2 under Windows.

News

• Many bug fixed and many new features.
• Significantly reduced compilation time for some programs.
• The new token _@, which denotes the current Flora-2 module.
• The new @prologall() module specification, which automatically converts the arguments of Prolog calls between the Flora-2 and Prolog representation as needed.
• The new reification operator ${...}. Say, x[m-> ${a[b->c]}] will reify the formula a[b->c]. This is in addition to the previously available meta-argument specification (called "bform" before and now changed to "meta").
• New syntax: ..., {constraint},... which allows Flora programs to use the CLPR constraint solver of XSB.

Bugfixes

• Works again under Windows.
• Numerous other small bugs.

Backward Incompatibility

• The predicate flThisModule/1 has been deprecated. Use the literal _@ to refer to the current module. This is more convenient and faster.
• The bform argument specifier is now called meta.

General

This release fixes many bugs, eliminates some restrictions, and adds new features.

News

• The most important new feature is the ability to check for undefined predicates and methods in debug mode (see the manual regarding checking undefinedness checks). This feature simplifies debugging considerably.
• Flora compiler now checks if a tabled predicate depends on an update operation and issues appropriate warnings. Such dependency is considered to be a likely program bug.
• Numbered anonymous oids added (e.g., _#123). They behave like regular anonymous oids (_#) in the sense that they are substituted by a new oid. However, numbered oids can be referenced within the same clause (e.g., _#12[self->_#12]).
• Optimized compilation of path expressions and nested terms.