tawny.owl — uk.org.russet/tawny-owl 2.3.0

Build ontologies in OWL.

! clj

&& clj

add-axiom clj

(add-axiom o axiom)

Adds an axiom from the given ontology, or the current one.

add-characteristics clj

(add-characteristics o property characteristic)

(add-characteristics o property & characteristic)

Add a list of characteristics to the property.

add-data-characteristics clj

(add-data-characteristics o property characteristic)

(add-data-characteristics o property & characteristic)

Add a list of characteristics to the property.

add-data-disjoint clj

(add-data-disjoint o name disjoint)

(add-data-disjoint o name & disjoint)

Adds a disjoint data property axiom to the ontology

add-data-domain clj

(add-data-domain o property domain)

(add-data-domain o property & domain)

Adds a domain to a data property.

add-data-equivalent clj

(add-data-equivalent o property equivalent)

(add-data-equivalent o property & equivalent)

Adds a equivalent data properties axiom.

add-data-range clj

(add-data-range o property range)

(add-data-range o property & range)

Adds a range to a data property.

add-data-subproperty clj

(add-data-subproperty o property sub)

(add-data-subproperty o property & sub)

Adds a sub property to a data property.

add-data-superproperty clj

(add-data-superproperty o property super)

(add-data-superproperty o property & super)

Adds a super property to a data property.

add-datatype-equivalent clj

(add-datatype-equivalent o datatype equivalent)

(add-datatype-equivalent o datatype & equivalent)

Adds a datatype equivalent axiom

add-different clj

(add-different o & individuals)

Adds all arguments as different individuals to the current ontology unless first arg is an ontology in which case this is used

add-disjoint clj

(add-disjoint o name disjoint)

(add-disjoint o name & disjoint)

Adds a disjoint axiom to the ontology.

add-disjoint-property clj

Adds a disjoint property axiom to the ontology

add-disjoint-union clj

(add-disjoint-union o clazz subclasses)

Adds a disjoint union axiom to all subclasses.

add-domain clj

(add-domain o property domain)

(add-domain o property & domain)

Adds all the entities in domainlist as domains to a property.

add-equivalent clj

(add-equivalent o name equivalent)

(add-equivalent o name & equivalent)

Adds an equivalent axiom to the ontology.

add-equivalent-property clj

Adds a equivalent data properties axiom.

add-fact clj

(add-fact o individual fact)

(add-fact o individual & fact)

Add FACTS to an INDIVIDUAL in the current ontology or ONTOLOGY if present. Facts are produced with fact' andfact-not'.

add-has-key clj

(add-has-key o class propertylist)

Adds a has-key to the class.

add-inverse clj

(add-inverse o property inverse)

(add-inverse o property & inverse)

Adds all the entities in inverselist as inverses to a property.

add-range clj

(add-range o property range)

(add-range o property & range)

Adds all the entities in rangelist as range to a property.

add-same clj

(add-same & individuals)

(add-same ontology & individuals)

Adds all arguments as the same individual to the current ontology or to ONTOLOGY if present.

add-subchain clj

(add-subchain o property subpropertylist)

Adds a property chain to property.

add-subclass clj

(add-subclass o name subclass)

(add-subclass o name & subclass)

Adds one or more subclasses to name in ontology.

add-subproperty clj

(add-subproperty o property subproperty)

(add-subproperty o property & subproperty)

Adds all items in superpropertylist to property as a superproperty.

add-superclass clj

(add-superclass o name superclass)

(add-superclass o name & superclass)

Adds one or more superclasses to name in ontology.

add-superproperty clj

(add-superproperty o property superproperty)

(add-superproperty o property & superproperty)

Adds all items in superpropertylist to property as a superproperty.

add-type clj

(add-type o individual clazz)

(add-type o individual & clazz)

Adds CLAZZES as a type to individual to current ontology or ONTOLOGY if present.

annotate clj

(annotate entity-or-list & annotation)

Given an entity or a list of entities, add annotations and return as an Entityable and Annotatable entity.

These entities are used to annotate the axiom describing the relationship between the entity and the places where this entity is used. So, for example, if an annotated class is added as a subclass of another, the SubClassOf axiom will be annotated.

Annotated clj

annotation clj

(annotation annotation-property literal)

(annotation annotation-property literal language)

Creates a new annotation. If literal is a string it is interpreted as a String in English. Otherwise, it can be any annotation value or object which can be co-erced to an IRI

annotation-property clj

(annotation-property o name & frames)

Creates a new annotation property.

annotation-property-explicit clj

(annotation-property-explicit o name frames)

Add this annotation property to the ontology

annotator clj

(annotator annotation-property)

Creates a new annotator function. Annotation-property maybe an OWLAnnotationProperty object or a string in which case it will be coerced into a OWLAnnotationProperty using iri or iri-for-name. The function returned can take an optional ontology argument which will be used in this case.

anonymous-individual clj

(anonymous-individual)

Return a new anonymous individual

as-disjoint clj

(as-disjoint & entities)

(as-disjoint & entities)

(as-disjoint ontology & entities)

All entities are declared as disjoint. Entities may be any structure and may also be a var. See also 'as-subclasses'.

as-disjoint-subclasses clj

(as-disjoint-subclasses superclass & subclasses)

(as-disjoint-subclasses o superclass & subclasses)

Declare all subclasses as disjoint

as-equivalent clj

(as-equivalent & entities)

(as-equivalent o & entities)

Declare the properties or classes as disjoint.

as-inverse clj

(as-inverse p1 p2)

(as-inverse o p1 p2)

Declare the two properties as inverse

as-iriable clj

(as-iriable entity)

If entity is a iriable do nothing, else throw an exception.

as-subclasses clj

(as-subclasses superclass & classes)

(as-subclasses superclass options & classes)

(as-subclasses superclass options & classes)

(as-subclasses ontology superclass options & classes)

All classes are given the superclass. The first item may be an ontology, followed by options.

:disjoint also sets the class disjoint. :cover also makes the subclasses cover the superclass.

at-least clj multimethod

Returns a minimum cardinality restriction.

at-most clj multimethod

Returns a maximum cardinality restriction.

backward-compatible-with clj

Returns a backward compatible with annotation.

backward-compatible-with-property clj

broadcast clj

(broadcast f)

broadcast-2 clj

(broadcast-2 f)

data-and clj

(data-and & types)

Returns the intersection of two data ranges.

data-at-least clj

(data-at-least number property)

Returns a data min cardinality restriction.

data-at-most clj

(data-at-most number property)

Returns a data max cardinality restriction.

data-exactly clj

Returns a data exact cardinality restriction.

data-get-fact clj

(data-get-fact property from to annotations)

Returns a data fact.

data-get-fact-not clj

(data-get-fact-not property from to annotations)

Returns a data negative fact.

data-has-value clj

(data-has-value property literal)

Returns a data has value restriction.

data-not clj

(data-not type)

Returns the complement of two data ranges.

data-oneof clj

(data-oneof & literals)

Returns a data one of restriction.

data-only clj

Returns a data all values from restriction.

data-or clj

(data-or & types)

Returns the union of two data ranges.

data-some clj

(data-some property data-range)

(data-some property & data-range)

Returns a data some values from restriction.

datatype clj

(datatype o name & frames)

Defines a new datatype.

datatype-explicit clj

(datatype-explicit name frames)

(datatype-explicit o name frames)

Defines a new datatype.

datatype-property clj

(datatype-property o name & frames)

Define a new datatype property

datatype-property-explicit clj

(datatype-property-explicit name frames)

(datatype-property-explicit o name frames)

Define a new datatype property with an explicit map

declare-classes clj macro

(declare-classes & args)

Declares all the classes given in args. Any args including and following the first keyword will be interpreted as frames for all the classes. Frame args will be evaluated multiple times so should be side-effect free.

This is mostly useful for forward declarations.

See `defclassn' to define many classes with different frames.

defaproperty clj macro

(defaproperty entity & frames)

Defines a new annotation property in the current ontology. See 'defclass' for more details on the syntax

default-ontology clj

(default-ontology f)

(default-ontology f a)

(default-ontology f a b)

(default-ontology f a b c)

(default-ontology f a b c d)

(default-ontology f a b c d e)

(default-ontology f a b c d e fa)

(default-ontology f a b c d e fa g)

(default-ontology f a b c d e fa g h)

(default-ontology f a b c d e fa g h i)

(default-ontology f a b c d e fa g h i j)

(default-ontology f a b c d e fa g h i j & args)

Invoke f ensuring the first argument is an ontology or nil. If the first argument is already an ontology use that, if not use the default ontology, or throw an IllegalStateException. To set the default ontology use either the defontology macro, or ontology-to-namespace. This function is multi-arity as a micro optimization, to avoid a variadic invocation.

default-ontology-hook clj

Hook called when the default ontology is used

defclass clj macro

(defclass entity & frames)

Define a new class. Accepts a set number of frames, each marked by a keyword :subclass, :equivalent, :annotation, :comment, :label or :disjoint. Each frame can contain an item, a list of items or any combination of the two. The class object is stored in a var called classname.

defclassn clj macro

(defclassn & classes)

Defines many classes at once.

Each class and associated frames should be supplied as a vector.

See `declare-classes' where frames (or just default frames) are not needed.

defcopy clj macro

(defcopy symb & args)

Takes an existing definition from another namespace and copies it into the current namespace with no changes in semantics. This can be useful for convenience, where one namespace should contain all the OWLObjects of another, or for forward declaration, where entities will be refined later.

This does not add the existing definition to the current ontology. In most cases this will have been imported.

defdatatype clj macro

(defdatatype entity & frames)

Defines a new datatype

defdproperty clj macro

(defdproperty entity & frames)

Defines a new datatype property

defentity clj macro

(defentity name docstring entity-function)

(defentity name docstring entity-function ontology-keyword)

Defines a new macro for defining OWL entities.

This macro allows easy definition of new macros similar to the defclass or defoproperty macro. It expects an entity-function which can accept an ontology or nil as a first argument, and then a set of frames. See defdontfn' ordefmontfn' which support the declaration of these functions. The ontology argument is taken from a first :ontology frame which is handled by this macro. This macro also marks the resultant var with :owl metadata.

The resultant macro takes arguments of the form [name :ontology o :frame1 f]. The ontology frame is optional.

defindividual clj macro

(defindividual entity & frames)

Declare a new individual

defnb clj macro

(defnb & body)

Defines a new function that broadcasts the first and consecutive arguments.

defnb2 clj macro

(defnb2 & body)

Define a new function that broadcasts over first, second and consecutive arguments.

defno clj macro

(defno & body)

Define a new function, that is always called with an ontology as the first argument. If the ontology is not supplied the default ontology will be used instead.

defontology clj macro

(defontology name & body)

Define a new ontology with `name'.

The following keys must be supplied. :iri -- the IRI for the new ontology :prefix -- the prefix used in the serialised version of the ontology

defoproperty clj macro

(defoproperty entity & frames)

Defines a new object property in the current ontology.

defrefine clj macro

(defrefine symb & args)

Takes an existing definition, add more frames.

The first element should be a namespace qualified symbol. The unqualified part of this will be used in the current namespace.

See also 'refine'

deprecated clj

Returns a deprecated annotation.

deprecated-add-data-superproperty clj deprecated

The same as add-data-superproperty but deprecated. This is to deprecated the :superproperty frame

deprecated-add-sub-annotation clj

The same as add-super-annotation used to implement the old add-sub-annotation functionality.

deprecated-add-subclass clj

deprecated-add-subpropertychain clj deprecated

This is the same as add-subchain, but marked as deprecated and used as the handler for :subpropertychain.

deprecated-add-superproperty clj deprecated

This is the same as add-superproperty but marked as deprecated and used as the handler for :subproperty.

deprecated-property clj

direct-instances clj

(direct-instances name)

(direct-instances o name)

Return all direct instances of NAME class.

direct-subclasses clj

(direct-subclasses name)

(direct-subclasses o name)

Returns the direct subclasses of name.

direct-subproperties clj

(direct-subproperties property)

(direct-subproperties o property)

Returns all direct subproperties of property.

direct-superclasses clj

(direct-superclasses name)

(direct-superclasses o name)

Returns the direct superclasses of name. Name can be either a class or a string name. Returns a list of class expressions.

direct-superproperties clj

(direct-superproperties property)

(direct-superproperties o property)

Return all direct superproperties of property.

disjoint-classes clj

(disjoint-classes o list)

Makes all elements in list disjoint. All arguments must of an instance of OWLClassExpression

disjoint-data-properties clj

(disjoint-data-properties o properties)

disjoint-properties clj

(disjoint-properties o properties)

Make all the properties in PROPERTIES disjoint.

disjoint? clj

(disjoint? a b)

(disjoint? o a b)

Returns t iff entities (classes or properties) are asserted to be disjoint.

entity-for-iri clj

(entity-for-iri o iri)

Return the OWLObject for a given IRI if it exists, checking 'ontology' first, but checking all loaded ontologies.

This function uses a heuristic to find the right entity. If you want more control use 'check-entity-set' and the '.getEntitiesInSignature' method of OWLOntology.

entity-for-string clj

(entity-for-string o string)

Returns the OWLObject for a given string. See 'entity-for-iri' for more details. Attempts both ontology specific iri to name conversion, and direct use of string as an IRI.

equivalent-classes clj

(equivalent-classes o list)

Makes all elements in list equivalent. All arguments must of an instance of OWLClassExpression

equivalent-data-properties clj

(equivalent-data-properties o properties)

equivalent-properties clj

(equivalent-properties o properties)

Adds properties as equivalent to the ontology.

equivalent? clj

(equivalent? a b)

(equivalent? o a b)

Returns t iff classes are asserted to be equivalent.

exactly clj multimethod

Returns an exact cardinality restriction.

fact clj

(fact property to)

Returns a fact assertion a relation by PROPERTY which can be either an object or data property toward either an individual or literal TO. This is the same as the function `is'.

fact-not clj

(fact-not property to)

Returns a fact asserting the lack of a relationship along PROPERTY toward an either an individual or literal TO.

fontology clj

(fontology f)

Return a function that always calls f with an ontology as the first argument.

frameify clj

(frameify explicit-f frame-keys)

(frameify explicit-f frame-keys hashify)

Return a framified function.

A frameified function is one that accepts keywords which take any number of arguments. These values are converted into a map.

EXPLICIT-F is the function that will be called. It should accept arguments of form (ontology name map) where MAP is generated from the arguments to the framified function.

FRAME-KEYS are the keywords which are valid for this function. Other values will raise an exception.

HASHIFY is the function used to convert between the flat list of arguments and the map. By default, this will split at every keyword.

The function returned has 'f-ontology' functionality; that is, if no ontology argument is supplied by the user, it will be provided elsewhere.

gci clj

(gci class subclass)

(gci o class subclass)

Adds one or more subclasses to name in ontology.

get-current-ontology clj

(get-current-ontology)

(get-current-ontology ns)

Gets the current ontology. Throws an exception if there is not current ontology

get-current-ontology-maybe clj

(get-current-ontology-maybe)

(get-current-ontology-maybe ns)

Gets the current ontology, or nil if there is not one.

get-fact clj multimethod

get-fact-not clj multimethod

get-prefix clj

(get-prefix o)

Returns the prefix for the given ontology, or the current ontology if none is given.

guess-individual-literal clj

(guess-individual-literal entity)

guess-type clj

(guess-type entity)

Guesses the type of the entity. Returns ::object, :data or :annotation or nil where the type cannot be guessed. IllegalArgumentException is thrown for arguments which make no sense (not an OWLObject, IRI, String or number).

What this means is, for a collection find the first entity for which we can guess a type for. For an OWLClass, OWLIndividual, OWLDatatype or OWLAnnotationProperty object return the appropriate value. For an IRI check the current ontology, the current ontology with its import closure, and all known ontologies with their import clojure. For a string convert to an IRI using the current ontology rules, and check again. Finally, check convert to an IRI with no transformation. nil is returned when the result is not clear.

guess-type-error clj

(guess-type-error & args)

Throws an exception always

has-self clj

(has-self property)

Returns an OWL has self restriction.

has-value clj multimethod

Returns a has-value restriction.

incompatible-with clj

Returns an incompatible with annotation.

incompatible-with-property clj

individual clj

(individual o name & frames)

individual-explicit clj

(individual-explicit name frames)

(individual-explicit o name frames)

Returns a new individual.

intern-owl clj macro

(intern-owl name entity)

Intern an OWL Entity. Compared to the clojure.core/intern function this signals a hook, and adds :owl true to the metadata. NAME must be a symbol

intern-owl-entity-hook clj

Hook called when an new var is created with an OWLObject, with the var

intern-owl-string clj

(intern-owl-string name entity)

(intern-owl-string ns name entity)

Interns an OWL Entity. Compared to the clojure.core/intern function this signals a hook, and adds :owl true to the metadata. NAME must be a strings

inverse clj

(inverse property)

Creates an object inverse of expression.

inverse? clj

(inverse? p1 p2)

(inverse? o p1 p2)

Returns t iff properties are asserted to be inverse

iri clj

(iri name)

Returns an IRI object given a string or URI. Does no transformation on the string; use 'iri-for-name' to perform ontology specific expansion

iri-for-name clj

(iri-for-name o name)

Returns an IRI object for the given name.

This is likely to become a property of the ontology at a later date, but at the moment it is very simple.

iriable? clj

(iriable? entity)

Returns true iff entity is an IRIable.

is clj

Returns a fact assertion a relation by PROPERTY which can be either an object or data property toward either an individual or literal TO

is-defined-by clj

Return an is defined by annotation.

is-defined-by-property clj

label clj

Return an OWL label annotation.

label-property clj

literal clj

(literal literal & {:keys [lang type]})

Returns a OWL2 literal.

literal' is the value of the literal and must be a string or a number. Anything else must by coerced into a string manually. Options can also be specified, with :lang definining the language whereliteral' is a string, and :type which is an OWLDatatype object.

max-inc clj

(max-inc to)

Returns a max inclusive restriction.

min-inc clj

(min-inc from)

Returns a min inclusive restriction.

min-max clj

(min-max from to)

Returns a min-max exclusive restriction.

min-max-inc clj

(min-max-inc from to)

Returns a min max inclusive restriction.

mrefine clj

(mrefine lo en & args)

object-and clj

(object-and & classes)

Returns an OWL intersection of restriction.

object-at-least clj

(object-at-least cardinality property)

(object-at-least cardinality property class)

Returns an OWL at-least cardinality restriction.

object-at-most clj

(object-at-most cardinality property)

(object-at-most cardinality property class)

Returns an OWL at-most cardinality restriction.

object-exactly clj

(object-exactly cardinality property)

(object-exactly cardinality property class)

Returns an OWL exact cardinality restriction.

object-get-fact clj

(object-get-fact property from to annotations)

Returns an OWL Object property assertion axiom.

object-get-fact-not clj

(object-get-fact-not property from to annotations)

Returns a negative OWL Object property assertion axiom.

object-has-value clj

(object-has-value property individual)

(object-has-value property & individual)

Adds an OWL has-value restriction.

object-not clj

(object-not & class)

Returns an OWL complement of restriction.

object-oneof clj

(object-oneof & individuals)

Returns an OWL one of property restriction.

object-only clj

(object-only property class)

(object-only property & class)

Returns an OWL all values from restriction.

object-or clj

(object-or & classes)

Returns an OWL union of restriction.

object-property clj

(object-property o name & frames)

Returns a new object property in the current ontology.

object-property-explicit clj

(object-property-explicit o name frames)

Returns an object-property. This requires an hash with a list value for each frame.

object-some clj

(object-some property class)

(object-some property & class)

Returns an OWL some values from restriction.

object-some-only clj

(object-some-only property & classes)

Returns an restriction combines the OWL some values from and all values from restrictions.

oneof clj multimethod

Returns a one-of restriction to the arguments of individuals or data ranges.

only clj multimethod

Returns a universal rescriction with another class or data range.

ontology clj

(ontology & args)

ontology-def-f clj

(ontology-def-f name body)

ontology-explicit clj

(ontology-explicit options)

Returns a new ontology. See 'defontology' for full description.

ontology-for-namespace clj

Map between namespaces and ontologies

ontology-options clj

(ontology-options o)

Returns the ontology options for 'ontology' or the current-ontology

ontology-options-atom clj

Ontology options. A map on a atom for each ontology

ontology-to-namespace clj

(ontology-to-namespace o)

(ontology-to-namespace ns o)

Sets the current ontology as defined by `defontology'

owl-and clj multimethod

Returns an intersection restriction to all of the arguments.

owl-class clj

(owl-class o name & frames)

Creates a new class in the current ontology. See 'defclass' for full details.

owl-class-explicit clj

(owl-class-explicit o name frames)

Creates a class in the current ontology. Frames is a map, keyed on the frame name, value a list of items (of other lists) containing classes. This function has a rigid syntax, and the more flexible 'owl-class' is normally preferred. However, this function should be slightly faster.

owl-comment clj

Return an OWL comment annotation

owl-comment-property clj

owl-data-factory clj

(owl-data-factory)

Returns the main factory for all other objects.

owl-import clj

(owl-import o)

(owl-import ontology-into o)

Adds a new import to the current ontology. o may be an ontology or an IRI

owl-max clj

(owl-max to)

Returns a data max exclusion restriction.

owl-min clj

(owl-min from)

Returns a data min exclusion restriction.

owl-not clj

(owl-not entity)

(owl-not property entity)

Returns a complement of restriction or negative property assertion axiom.

owl-nothing clj

(owl-nothing)

Returns OWL nothing.

owl-only clj

owl-ontology-manager clj

(owl-ontology-manager)

The single OWLOntologyManager used by Tawny.

owl-or clj multimethod

Returns an union restriction to all of the arguments.

owl-some clj multimethod

Returns an existential restriction with another class or a data range.

owl-thing clj

(owl-thing)

Returns OWL thing.

owl2datatypes clj

A map of keywords to the OWL2Datatypes values

re-annotate clj

(re-annotate entity annotated)

Returns a Annotated with the entity and the same annotations as annotated.

This is generally intended to transfer annotations after, for example, the entity has been derived from the existing entity. So, we might want to replace an IRI with an OWLObject, but the same annotations.

refine clj multimethod

Takes an existing definition, adds it to the current ontology, and then adds more frames. owlentity is the OWLEntity to be refined, and frames are the additional frames. The keys to the frames must be appropriate for the type of entity. See 'owl-class' or 'object-property' for more details.

This is useful for two main reasons. First, to build class definitions in two places and add frames in both of these places. For simple forward declaration 'declare-classes' is better. The second is where the same class needs to appear in two ontologies, but with more axioms in the second. This can enable, for example, building two interlocking ontologies with different OWL profiles.

remove-axiom clj

(remove-axiom o & axiom-list)

Removes a list of axioms from the given ontology, or the current one.

remove-entity clj

(remove-entity o entity)

Remove from the ontology an entity created and added by owl-class, defclass, object-property or defoproperty. Entity is the value returned by these functions.

This removes all the axioms that were added. So, for example, a form such as

(defclass a :subclass b :equivalent c)

adds three axioms -- it declares a, makes it a subclass of b, and equivalent of c.

remove-ontology-hook clj

Hook called immediately after an ontology is removed from the owl-ontology-manager.

remove-ontology-maybe clj

(remove-ontology-maybe ontologyid)

Removes the ontology with the given ID from the manager. This calls the relevant hooks, so is better than direct use of the OWL API.

run-intern-hook clj

(run-intern-hook var)

Run intern-owl-entity hooks and return first argument.

save-ontology clj

(save-ontology filename)

(save-ontology o filename)

(save-ontology o filename format)

(save-ontology o filename format prepend)

Save the current 'ontology' in the file or `filename' if given. If no ontology is given, use the current-ontology

see-also clj

Returns a see-also annotation.

see-also-property clj

some-only clj multimethod

Returns a list containing existential restrictions to each of the arguments, and universal relationship to the union of each of the arguments.

span clj macro

(span comparitor & args)

Returns a numeric datatype restriction, identified by symbol. For example, (span < 10) returns a max exclusive restriction.

subclass? clj

(subclass? name subclass)

(subclass? o name subclass)

Returns true if name has subclass as a subclass.

subclasses clj

(subclasses class)

(subclasses o class)

Return all subclasses of class.

subproperties clj

(subproperties property)

(subproperties o property)

Returns all subproperties of property.

subproperty? clj

(subproperty? property subproperty)

(subproperty? o property subproperty)

Returns true if property is a subproperty of subproperty.

superclass? clj

(superclass? name superclass)

(superclass? o name superclass)

Returns true if name is asserted to be a superclass.

superclasses clj

(superclasses class)

(superclasses o class)

Return all superclasses of class. class is not returned unless it is explicitly stated to be a direct or indirect superclass of itself.

superproperties clj

(superproperties property)

(superproperties o property)

Return all superproperties of a property.

superproperty? clj

(superproperty? property superproperty)

(superproperty? o property superproperty)

Return true if superproperty is a superproperty of property.

tawny-name-property clj

version-info clj

Returns a version info annotation.

version-info-property clj

with-prefix clj macro

(with-prefix prefix & body)

Adds a prefix to all defclass macros in scope. This is a convenience macro and is lexically scoped.

with-probe-axioms clj macro

(with-probe-axioms & args)

Evaluate the body with a number of axioms. Then delete these axioms from the ontology.

This is mostly useful for test cases. Axioms can be added, consistency or inconsistency can be checked then removed, leaving the ontology effectively unchanged.

with-probe-entities clj macro

(with-probe-entities bindings & body)

(with-probe-entities ontology bindings & body)

Evaluate BODY with a number of entities defined. Then delete these entities from the ontology. BINDINGS are a vector with similar to let. The first argument should evaluate to the ontology, or the current ontology will be used. Statements inside bindings are evaluated with the current-ontology set to ONTOLOGY. Entities added to ONTOLOGY are removed from ONTOLOGY; so if they are added to a different ontology explicitly, they will remain there after the completion of this form.

with-suffix clj macro

(with-suffix suffix & body)

Adds a suffix to all defclass macros in scope. This is a convenience macro and is lexically scoped.

|| clj