{ "category": { "body":"\n:- category(${1:Category},\n\timplements(${2:Protocol})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_category.\n", "description":"Category with protocol", "prefix":"category", "scope":"source.logtalk" }, "category1": { "body":"\n:- category(${1:Category}).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${2:Author}',\n\t\tdate is ${3:$CURRENT_YEAR}/${4:$CURRENT_MONTH}/${5:$CURRENT_DATE},\n\t\tcomment is '${6:Description}'\n\t]).\n\n$0\n\n:- end_category.\n", "description":"Category", "prefix":"category", "scope":"source.logtalk" }, "category2": { "body":"\n:- category(${1:Category},\n\tcomplements(${2:Object})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_category.\n", "description":"Complementing category", "prefix":"category", "scope":"source.logtalk" }, "category3": { "body":"\n:- category(${1:ExtendedCategory},\n\textends(${2:MinimalCategory})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_category.\n", "description":"Extended category", "prefix":"category", "scope":"source.logtalk" }, "class": { "body":"\n:- object(${1:Class},\n\timplements(${2:Protocol}),\n\timports(${3:Category}),\n\tinstantiates(${4:Metaclass}),\n\tspecializes(${5:Superclass})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${6:Author}',\n\t\tdate is ${7:$CURRENT_YEAR}/${8:$CURRENT_MONTH}/${9:$CURRENT_DATE},\n\t\tcomment is '${10:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Class with all", "prefix":"class", "scope":"source.logtalk" }, "class1": { "body":"\n:- object(${1:Class},\n\timports(${2:Category}),\n\tspecializes(${3:Superclass})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${4:Author}',\n\t\tdate is ${5:$CURRENT_YEAR}/${6:$CURRENT_MONTH}/${7:$CURRENT_DATE},\n\t\tcomment is '${8:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Class with category", "prefix":"class", "scope":"source.logtalk" }, "class2": { "body":"\n:- object(${1:Class},\n\tinstantiates(${2:Metaclass}),\n\tspecializes(${3:Superclass})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${4:Author}',\n\t\tdate is ${5:$CURRENT_YEAR}/${6:$CURRENT_MONTH}/${7:$CURRENT_DATE},\n\t\tcomment is '${8:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Class with metaclass", "prefix":"class", "scope":"source.logtalk" }, "class3": { "body":"\n:- object(${1:Class},\n\timplements(${2:Protocol}),\n\tspecializes(${3:Superclass})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${4:Author}',\n\t\tdate is ${5:$CURRENT_YEAR}/${6:$CURRENT_MONTH}/${7:$CURRENT_DATE},\n\t\tcomment is '${8:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Class with protocol", "prefix":"class", "scope":"source.logtalk" }, "class4": { "body":"\n:- object(${1:Class},\n\tspecializes(${2:Superclass})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Class", "prefix":"class", "scope":"source.logtalk" }, "directive:category": { "body":":- category(${1:name}).\n\t$2\n:- end_category.\n", "prefix":":- cat", "scope":"source.logtalk" }, "directive:catrelation": { "body":"${1|implements,extends,complements|}($2)", "description":"relations between categories", "prefix":"crel" }, "directive:object": { "body":":- object(${1:name}).\n\t$2\n:- end_object.\n", "prefix":":- obj", "scope":"source.logtalk" }, "directive:objrelation": { "body":"${1|imports,implements,extends,instantiates,specializes|}($2)", "description":"relations between objects", "prefix":"orel" }, "directive:prorelation": { "body":"extends(${1})", "description":"relations between categories", "prefix":"ext" }, "directive:protocol": { "body":":- protocol(${1:name}).\n\t$2\n:- end_protocol.\n", "prefix":":- pro", "scope":"source.logtalk" }, "directives:alias/2": { "body":":- alias(${1:Entity}, ${2:PredicateAliases}).\n", "description":"Template and modes\nalias(@entity_identifier, +list(predicate_indicator_alias))\nalias(@entity_identifier, +list(non_terminal_indicator_alias))\n\nDescription\nDeclares predicate and grammar rule non-terminal aliases. A predicate (non-terminal) alias is an alternative name for a predicate (non-terminal) declared or defined in an extended protocol, an implemented protocol, an extended category, an imported category, an extended prototype, an instantiated class, or a specialized class. Predicate aliases may be used to solve conflicts between imported or inherited predicates. It may also be used to give a predicate (non-terminal) a name more appropriated in its usage context. This directive may be used in objects, protocols, and categories.\n", "prefix":":- alias", "scope":"source.logtalk" }, "directives:built_in/0": { "body":":- built_in$0.\n", "description":"Template and modes\nbuilt_in\n\nDescription\nDeclares an entity as built-in. Built-in entities cannot be redefined once loaded.\n", "prefix":":- built_in", "scope":"source.logtalk" }, "directives:coinductive/1": { "body":":- coinductive(${1:Functor/Arity}).\n", "description":"Template and modes\ncoinductive(+predicate_indicator_term)\ncoinductive(+coinductive_predicate_template_term)\n\nDescription\nThis is an experimental directive, used for declaring coinductive predicates. Requires a back-end Prolog compiler with minimal support for cyclic terms. The current implementation of coinduction allows the generation of only the basic cycles but all valid solutions should be recognized. Use a predicate indicator as argument when all the coinductive predicate arguments are relevant for coinductive success. Use a template when only some coinductive predicate arguments (represented by a \"+\") should be considered when testing for coinductive success (represent the arguments that should be disregarded by a \"-\"). It's possible to define local coinductive_success_hook/2 or coinductive_success_hook/1 predicates that are automatically called with the coinductive predicate term resulting from a successful unification with an ancestor goal as first argument. The second argument, when present, is the coinductive hypothesis (i.e. the ancestor goal) used. These hook predicates can provide an alternative to the use of tabling when defining some coinductive predicates. There is no overhead when these hook predicates are not defined.\n", "prefix":":- coinductive", "scope":"source.logtalk" }, "directives:discontiguous/1": { "body":":- discontiguous(${1:Functor/Arity}).\n", "description":"Template and modes\ndiscontiguous(+predicate_indicator_term)\ndiscontiguous(+non_terminal_indicator_term)\n\nDescription\nDeclares discontiguous predicates and discontiguous grammar rule non-terminals. The use of this directive should be avoided as not all backend Prolog compilers support discontiguous predicates.\n", "prefix":":- discontiguous", "scope":"source.logtalk" }, "directives:dynamic/0": { "body":":- dynamic$0.\n", "description":"Template and modes\ndynamic\n\nDescription\nDeclares an entity and its contents as dynamic. Dynamic entities can be abolished at runtime.\n", "prefix":":- dynamic", "scope":"source.logtalk" }, "directives:dynamic/1": { "body":":- dynamic(${1:Functor/Arity}).\n", "description":"Template and modes\ndynamic(+qualified_predicate_indicator_term)\ndynamic(+qualified_non_terminal_indicator_term)\n\nDescription\nDeclares dynamic predicates and dynamic grammar rule non-terminals. Note that an object can be static and have both static and dynamic predicates/non-terminals. Dynamic predicates cannot be declared as synchronized. When the dynamic predicates are local to an object, declaring them also as private predicates allows the Logtalk compiler to generate optimized code for asserting and retracting predicate clauses. Categories can also contain dynamic predicate directives but cannot contain clauses for dynamic predicates.\n", "prefix":":- dynamic", "scope":"source.logtalk" }, "directives:elif/1": { "body":":- elif(${1:Goal}).\n", "description":"Template and modes\nelif(@callable)\n\nDescription\nSupports embedded conditionals when performing conditional compilation. The code following the directive is compiled if Goal is true. The goal is subjected to goal expansion when the directive occurs in a source file.\n", "prefix":":- elif", "scope":"source.logtalk" }, "directives:else/0": { "body":":- else$0.\n", "description":"Template and modes\nelse\n\nDescription\nStarts a else branch when performing conditional compilation.\n", "prefix":":- else", "scope":"source.logtalk" }, "directives:encoding/1": { "body":":- encoding(${1:Encoding}).\n", "description":"Template and modes\nencoding(+atom)\n\nDescription\nDeclares the source file text encoding. This is an experimental source file directive, which is only supported on some back-end Prolog compilers. When used, this directive must be the first term in the source file in the first line. Currently recognized encodings values include 'US-ASCII', 'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-15', 'UCS-2', 'UCS-2LE', 'UCS-2BE', 'UTF-8', 'UTF-16', 'UTF-16LE', 'UTF-16BE', 'UTF-32', 'UTF-32LE', 'UTF-32BE', 'Shift_JIS', and 'EUC-JP'. Be sure to use an encoding supported by the chosen back-end Prolog compiler (whose adapter file must define a table that translates between the Logtalk and Prolog-specific atoms that represent each supported encoding). When writing portable code that cannot be expressed using ASCII, 'UTF-8' is usually the best choice.\n", "prefix":":- encoding", "scope":"source.logtalk" }, "directives:if/1": { "body":":- if(${1:Goal}).\n", "description":"Template and modes\nif(@callable)\n\nDescription\nStarts conditional compilation. The code following the directive is compiled if Goal is true. The goal is subjected to goal expansion when the directive occurs in a source file.\n", "prefix":":- if", "scope":"source.logtalk" }, "directives:include/1": { "body":":- include(${1:File}).\n", "description":"Template and modes\ninclude(@source_file_name)\n\nDescription\nIncludes a file contents, which must be valid terms, at the place of occurrence of the directive. The file can be specified as a relative path, an absolute path, or using library notation and is expanded as a source file name. Relative paths are interpreted as relative to the path of the file contining the directive.\n", "prefix":":- include", "scope":"source.logtalk" }, "directives:info/1": { "body":":- info(${1:List}).\n", "description":"Template and modes\ninfo(+entity_info_list)\n\nDescription\nDocumentation directive for objects, protocols, and categories. The directive argument is a list of pairs using the format Key is Value. See the documenting Logtalk programs section for a description of the default keys.\n", "prefix":":- info", "scope":"source.logtalk" }, "directives:info/2": { "body":":- info(${1:Functor/Arity}, ${2:List}).\n", "description":"Template and modes\ninfo(+predicate_indicator, +predicate_info_list)\ninfo(+non_terminal_indicator, +predicate_info_list)\n\nDescription\nDocumentation directive for predicates and grammar rule non-terminals. The first argument is either a predicate indicator or a grammar rule non-terminal indicator. The second argument is a list of pairs using the format Key is Value. See the documenting Logtalk programs section for a description of the default keys.\n", "prefix":":- info", "scope":"source.logtalk" }, "directives:initialization/1": { "body":":- initialization(${1:Goal}).\n", "description":"Template and modes\ninitialization(@callable)\n\nDescription\nWhen used within an object, this directive defines a goal to be called immediately after the object has been loaded into memory. When used at a global level within a source file, this directive defines a goal to be called immediately after the compiled source file is loaded into memory.\n", "prefix":":- initialization", "scope":"source.logtalk" }, "directives:meta_non_terminal/1": { "body":":- meta_non_terminal(${1:MetaNonTerminalTemplate}).\n", "description":"Template and modes\nmeta_non_terminal(+meta_non_terminal_template_term)\n\nmeta_non_terminal(+object_identifier::+meta_non_terminal_template_term)\nmeta_non_terminal(+category_identifier::+meta_non_terminal_template_term)\n\nmeta_non_terminal(+module_identifier:+meta_non_terminal_template_term)\n\nDescription\nDeclares meta-non-terminals, i.e., non-terminals that have arguments that will be called as non-terminals (or grammar rule bodies). An argument may also be a closure instead of a goal if the non-terminal uses the call//1-N Logtalk built-in methods to construct and call the actual non-terminal from the closure and the additional arguments.\n", "prefix":":- meta_non_terminal", "scope":"source.logtalk" }, "directives:meta_predicate/1": { "body":":- meta_predicate(${1:MetaPredicateTemplate}).\n", "description":"Template and modes\nmeta_predicate(+meta_predicate_template_term)\n\nmeta_predicate(+object_identifier::+meta_predicate_template_term)\nmeta_predicate(+category_identifier::+meta_predicate_template_term)\n\nmeta_predicate(+module_identifier:+meta_predicate_template_term)\n\nDescription\nDeclares meta-predicates, i.e., predicates that have arguments that will be called as goals. An argument may also be a closure instead of a goal if the meta-predicate uses the call/N Logtalk built-in methods to construct and call the actual goal from the closure and the additional arguments.\n", "prefix":":- meta_predicate", "scope":"source.logtalk" }, "directives:mode/2": { "body":":- mode(${1:Mode}, ${2:NumberOfProofs}).\n", "description":"Template and modes\nmode(+predicate_mode_term, +number_of_proofs)\nmode(+non_terminal_mode_term, +number_of_proofs)\n\nDescription\nMost predicates can be used with several instantiations modes. This directive enables the specification of each instantiation mode and the corresponding number of proofs (not necessarily distinct solutions). You may also use this directive for documenting grammar rule non-terminals.\n", "prefix":":- mode", "scope":"source.logtalk" }, "directives:multifile/1": { "body":":- multifile(${1:Functor/Arity}).\n", "description":"Template and modes\nmultifile(+qualified_predicate_indicator_term)\nmultifile(+qualified_non_terminal_indicator_term)\n\nDescription\nDeclares multifile predicates and multifile grammar rule non-terminals. In the case of object or category multifile predicates, the predicate (or non-terminal) must also have a scope directive in the object or category holding its primary declaration (i.e. the declaration without the Entity:: prefix). Entities holding multifile predicate primary declarations must be compiled and loaded prior to any entities contributing with clauses for the multifile predicates.\n", "prefix":":- multifile", "scope":"source.logtalk" }, "directives:op/3": { "body":":- op(${1:Precedence}, ${2:Associativity}, ${3:Operator}).\n", "description":"Template and modes\nop(+integer, +associativity, +atom_or_atom_list)\n\nDescription\nDeclares operators. Operators declared inside entities have local scope. Global operators can be declared inside a source file by writing the respective directives before the entity opening directives.\n", "prefix":":- op", "scope":"source.logtalk" }, "directives:private/1": { "body":":- private(${1:Functor/Arity}).\n", "description":"Template and modes\nprivate(+predicate_indicator_term)\nprivate(+non_terminal_indicator_term)\nprivate(+operator_declaration)\n\nDescription\nDeclares private predicates, private grammar rule non-terminals, and private operators. A private predicate can only be called from the object containing the private directive. A private non-terminal can only be used in a call of the phrase/2 and phrase/3 methods from the object containing the private directive.\n", "prefix":":- private", "scope":"source.logtalk" }, "directives:protected/1": { "body":":- protected(${1:Functor/Arity}).\n", "description":"Template and modes\nprotected(+predicate_indicator_term)\nprotected(+non_terminal_indicator_term)\nprotected(+operator_declaration)\n\nDescription\nDeclares protected predicates, protected grammar rule non-terminals, and protected operators. A protected predicate can only be called from the object containing the directive or from an object that inherits the directive. A protected non-terminal can only be used as an argument in a phrase/2 and phrase/3 calls from the object containing the directive or from an object that inherits the directive. Protected operators are not inherited but declaring them provides useful information for defining descendant objects.\n", "prefix":":- protected", "scope":"source.logtalk" }, "directives:public/1": { "body":":- public(${1:Functor/Arity}).\n", "description":"Template and modes\npublic(+predicate_indicator_term)\npublic(+non_terminal_indicator_term)\npublic(+operator_declaration)\n\nDescription\nDeclares public predicates, public grammar rule non-terminals, and public operators. A public predicate can be called from any object. A public non-terminal can be used as an argument in phrase/2 and phrase/3 calls from any object. Public operators are not exported but declaring them provides useful information for defining client objects.\n", "prefix":":- public", "scope":"source.logtalk" }, "directives:set_logtalk_flag/2": { "body":":- set_logtalk_flag(${1:Flag}, ${2:Value}).\n", "description":"Template and modes\nset_logtalk_flag(+atom, +nonvar)\n\nDescription\nSets Logtalk flag values. The scope of this directive is the entity or the source file containing it. For global scope, use the corresponding set_logtalk_flag/2 built-in predicate within an initialization/1 directive.\n", "prefix":":- set_logtalk_flag", "scope":"source.logtalk" }, "directives:synchronized/1": { "body":":- synchronized(${1:Functor/Arity}).\n", "description":"Template and modes\nsynchronized(+predicate_indicator_term)\nsynchronized(+non_terminal_indicator_term)\n\nDescription\nDeclares synchronized predicates and synchronized grammar rule non-terminals. A synchronized predicate (or synchronized non-terminal) is protected by a mutex in order to allow for thread synchronization when proving a call to the predicate (or non-terminal). All predicates (and non-terminals) declared in the same synchronized directive share the same mutex. In order to use a separate mutex for each predicate (non-terminal) so that they are independently synchronized, a per-predicate synchronized directive must be used.\n", "prefix":":- synchronized", "scope":"source.logtalk" }, "directives:threaded/0": { "body":":- threaded$0.\n", "description":"Template and modes\nthreaded\n\nDescription\nDeclares that an object supports concurrent calls and asynchronous messages. Any object containing calls to the built-in multi-threading predicates (or importing a category that contains such calls) must include this directive.\n", "prefix":":- threaded", "scope":"source.logtalk" }, "directives:use_module/2": { "body":":- use_module(${1:Module}, ${2:Predicates}).\n", "description":"Template and modes\nuse_module(+module_identifier, +predicate_indicator_list)\n\nDescription\nThis directive declares that all calls (made from predicates defined in the category or object containing the directive) to the specified predicates are to be interpreted as calls to explicitly-qualified module predicates. Thus, this directive may be used to simplify writing of predicate definitions by allowing the programmer to omit the Module: prefix when using the predicates listed in the directive (as long as the predicate calls do not occur as arguments for non-standard Prolog meta-predicates not declared on the adapter files). It is also possible to include operator declarations, op(Precedence, Associativity, Operator), in the second argument.\n", "prefix":":- use_module", "scope":"source.logtalk" }, "directives:uses/2": { "body":":- uses(${1:Object}, ${2:Predicates}).\n", "description":"Template and modes\nuses(+object_identifier, +predicate_indicator_list)\nuses(+object_identifier, +predicate_indicator_alias_list)\n\nuses(+object_identifier, +non_terminal_indicator_list)\nuses(+object_identifier, +non_terminal_indicator_alias_list)\n\nDescription\nDeclares that all calls made from predicates (or non-terminals) defined in the category or object containing the directive to the specified predicates (or non-terminals) are to be interpreted as messages to the specified object. Thus, this directive may be used to simplify writing of predicate definitions by allowing the programmer to omit the Object:: prefix when using the predicates listed in the directive (as long as the calls do not occur as arguments for non-standard Prolog meta-predicates not declared on the adapter files). It is also possible to include operator declarations, op(Precedence, Associativity, Operator), in the second argument.\n", "prefix":":- uses", "scope":"source.logtalk" }, "instance": { "body":"\n:- object(${1:Instance},\n\timplements(${2:Protocol}),\n\timports(${3:Category}),\n\tinstantiates(${4:Class})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${5:Author}',\n\t\tdate is ${6:$CURRENT_YEAR}/${7:$CURRENT_MONTH}/${8:$CURRENT_DATE},\n\t\tcomment is '${9:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Instance with all", "prefix":"instance", "scope":"source.logtalk" }, "instance1": { "body":"\n:- object(${1:Instance},\n\timports(${2:Category}),\n\tinstantiates(${3:Class})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${4:Author}',\n\t\tdate is ${5:$CURRENT_YEAR}/${6:$CURRENT_MONTH}/${7:$CURRENT_DATE},\n\t\tcomment is '${8:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Instance with category", "prefix":"instance", "scope":"source.logtalk" }, "instance2": { "body":"\n:- object(${1:Instance},\n\timplements(${2:Protocol}),\n\tinstantiates(${3:Class})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${4:Author}',\n\t\tdate is ${5:$CURRENT_YEAR}/${6:$CURRENT_MONTH}/${7:$CURRENT_DATE},\n\t\tcomment is '${8:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Instance with protocol", "prefix":"instance", "scope":"source.logtalk" }, "instance3": { "body":"\n:- object(${1:Instance},\n\tinstantiates(${2:Class})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Instance", "prefix":"instance", "scope":"source.logtalk" }, "methods:abolish/1": { "body":"abolish(${1:Predicate})$0\n", "description":"Template and modes\nabolish(+predicate_indicator)\n\nDescription\nAbolishes a runtime declared dynamic predicate or a local dynamic predicate. When the predicate indicator for Head is declared in a uses/2 or use_module/2 directive, the predicate is abolished in the referenced object or module. Otherwise the predicate is abolished in an object's database. In the case of objects, only predicates that are dynamically declared (using a call to the asserta/1 or assertz/1 built-in methods) can be abolished.\n", "prefix":"abolish", "scope":"source.logtalk" }, "methods:after/3": { "body":"after(${1:Object}, ${2:Message}, ${3:Sender})$0\n", "description":"Template and modes\nafter(?object_identifier, ?callable, ?object_identifier)\n\nDescription\nUser-defined method for handling after events. This method is declared in the monitoring built-in protocol as a public predicate. Note that you can make its scope protected or private by using, respectively, protected or private implementation of the monitoring protocol.\n", "prefix":"after", "scope":"source.logtalk" }, "methods:ask_question/5": { "body":"ask_question(${1:Question}, ${2:Kind}, ${3:Component}, ${4:Check}, ${5:Answer})$0\n", "description":"Template and modes\nask_question(+nonvar, +nonvar, +nonvar, +callable, -term)\n\nDescription\nBuilt-in method for asking a question represented by a term, Question, which is converted to the question text using the logtalk::message_tokens(Question, Component) hook predicate. This method is declared in the logtalk built-in object as a public predicate. The default question prompt and the input stream used for each Kind-Component pair can be found using the logtalk::question_prompt_stream(Kind, Component, Prompt, Stream) hook predicate. The Check argument is a closure that is converted into a checking goal by extending it with the user supplied answer. This predicate implements a read-loop that terminates when the checking predicate succeeds.\n", "prefix":"ask_question", "scope":"source.logtalk" }, "methods:asserta/1": { "body":"asserta(${1:Head})$0\n", "description":"Template and modes\nasserta(+clause)\n\nDescription\nAsserts a clause as the first one for a dynamic predicate. When the predicate indicator for Head is declared in a uses/2 or use_module/2 directive, the clause is asserted in the referenced object or module. Otherwise the clause is asserted for an object's dynamic predicate. If the predicate is not previously declared (using a scope directive), then a dynamic predicate declaration is added to the object (assuming that we are asserting locally or that the compiler flag dynamic_declarations was set to allow when the object was created or compiled).\n", "prefix":"asserta", "scope":"source.logtalk" }, "methods:assertz/1": { "body":"assertz(${1:Head})$0\n", "description":"Template and modes\nassertz(+clause)\n\nDescription\nAsserts a clause as the last one for a dynamic predicate. When the predicate indicator for Head is declared in a uses/2 or use_module/2 directive, the clause is asserted in the referenced object or module. Otherwise the clause is asserted for an object's dynamic predicate. If the predicate is not previously declared (using a scope directive), then a dynamic predicate declaration is added to the object (assuming that we are asserting locally or that the compiler flag dynamic_declarations was set to allow when the object was created or compiled).\n", "prefix":"assertz", "scope":"source.logtalk" }, "methods:bagof/3": { "body":"bagof(${1:Template}, ${2:Goal}, ${3:List})$0\n", "description":"Template and modes\nbagof(@term, +callable, -list)\n\nDescription\nCollects a bag of solutions for the goal for each set of instantiations of the free variables in the goal. The order of the elements in the bag follows the order of the goal solutions. The free variables in the goal are the variables that occur in the goal but not in the template. Free variables can be ignored, however, by using the ^/2 existential qualifier. For example, if T is term containing all the free variables that we want to ignore, we can write T^Goal. Note that the term T can be written as V1^V2^....\n", "prefix":"bagof", "scope":"source.logtalk" }, "methods:before/3": { "body":"before(${1:Object}, ${2:Message}, ${3:Sender})$0\n", "description":"Template and modes\nbefore(?object_identifier, ?callable, ?object_identifier)\n\nDescription\nUser-defined method for handling before events. This method is declared in the monitoring built-in protocol as a public predicate. Note that you can make its scope protected or private by using, respectively, protected or private implementation of the monitoring protocol.\n", "prefix":"before", "scope":"source.logtalk" }, "methods:call//1-N": { "body":"call(${1:Closure})$0\n", "description":"Template and modes\ncall(+callable)\ncall(+callable, ?term)\ncall(+callable, ?term, ?term)\n...\n\nDescription\nThis non-terminal takes a closure and is processed by appending the input list of tokens and the list of remaining tokens to the arguments of the closure. This built-in non-terminal is interpreted as a private non-terminal and thus cannot be used as a message to an object. When using a back-end Prolog compiler supporting a module system, calls in the format call(Module:Closure) may also be used. By using as argument a lambda expression, this built-in non-terminal provides controlled access to the input list of tokens and to the list of the remaining tokens processed by the grammar rule containing the call.\n", "prefix":"call", "scope":"source.logtalk" }, "methods:call/1-N": { "body":"call(${1:Goal})$0\n", "description":"Template and modes\ncall(+callable)\ncall(+callable, ?term)\ncall(+callable, ?term, ?term)\n...\n\nDescription\nCalls a goal, which might be constructed by appending additional arguments to a closure. The upper limit for N depends on the upper limit for the arity of a compound term of the back-end Prolog compiler. This built-in meta-predicate is declared as a private method and thus cannot be used as a message to an object. The Closure argument can also be a lambda expression or a Logtalk control construct. When using a back-end Prolog compiler supporting a module system, calls in the format call(Module:Closure, Arg1, ...) may also be used.\n", "prefix":"call", "scope":"source.logtalk" }, "methods:catch/3": { "body":"catch(${1:Goal}, ${2:Catcher}, ${3:Recovery})$0\n", "description":"Template and modes\ncatch(?callable, ?term, ?term)\n\nDescription\nCatches exceptions thrown by a goal. See the Prolog ISO standard definition. This built-in meta-predicate is declared as a private method and thus cannot be used as a message to an object.\n", "prefix":"catch", "scope":"source.logtalk" }, "methods:clause/2": { "body":"clause(${1:Head}, ${2:Body})$0\n", "description":"Template and modes\nclause(+callable, ?body)\n\nDescription\nEnumerates, by backtracking, the clauses of a dynamic predicate. When the predicate indicator for Head is declared in a uses/2 or use_module/2 directive, the predicate enumerates the clauses in the referenced object or module. Otherwise it enumerates the clauses for an object's dynamic predicate.\n", "prefix":"clause", "scope":"source.logtalk" }, "methods:coinductive_success_hook/1-2": { "body":"coinductive_success_hook(${1:Head}, ${2:Hypothesis})$0\n", "description":"Template and modes\ncoinductive_success_hook(+callable, +callable)\ncoinductive_success_hook(+callable)\n\nDescription\nUser-defined hook predicates that are automatically called in case of coinductive success when proving a query for a coinductive predicates. The hook predicates are called with the head of the coinductive predicate on coinductive success and, optionally, with the hypothesis used that to reach coinductive success.\n", "prefix":"coinductive_success_hook", "scope":"source.logtalk" }, "methods:context/1": { "body":"context(${1:Context})$0\n", "description":"Template and modes\ncontext(--callable)\n\nDescription\nReturns the execution context for a predicate call using the format logtalk(Call,ExecutionContext). Mainly used for providing a default error context when type-checking predicate arguments. The ExecutionContext should be regarded as an opaque term, which can be decoded using the logtalk::execution_context/7 predicate. Calls to this predicate are inlined at compilation time.\n", "prefix":"context", "scope":"source.logtalk" }, "methods:current_op/3": { "body":"current_op(${1:Priority}, ${2:Specifier}, ${3:Operator})$0\n", "description":"Template and modes\ncurrent_op(?operator_priority, ?operator_specifier, ?atom)\n\nDescription\nEnumerates, by backtracking, the visible operators declared for an object. Operators not declared using a scope directive are not enumerated.\n", "prefix":"current_op", "scope":"source.logtalk" }, "methods:current_predicate/1": { "body":"current_predicate(${1:Predicate})$0\n", "description":"Template and modes\ncurrent_predicate(?predicate_indicator)\n\nDescription\nEnumerates, by backtracking, visible user predicates. When the predicate is declared in a uses/2 or use_module/2 directive, predicates are enumerated for the referenced object or module. Otherwise predicates are enumerated for an object. In the case of objects, predicates not declared using a scope directive are not enumerated.\n", "prefix":"current_predicate", "scope":"source.logtalk" }, "methods:eos//0": { "body":"eos$0$0\n", "description":"Template and modes\neos\n\nDescription\nThis non-terminal matches the end-of-input. It is implemented by checking that the implicit difference list unifies with []-[]. \n", "prefix":"eos", "scope":"source.logtalk" }, "methods:expand_goal/2": { "body":"expand_goal(${1:Goal}, ${2:ExpandedGoal})$0\n", "description":"Template and modes\nexpand_goal(?term, ?term)\n\nDescription\nExpands a goal.\n", "prefix":"expand_goal", "scope":"source.logtalk" }, "methods:expand_term/2": { "body":"expand_term(${1:Term}, ${2:Expansion})$0\n", "description":"Template and modes\nexpand_term(?term, ?term)\n\nDescription\nExpands a term. The most common use is to expand a grammar rule into a clause. Users may override the default Logtalk grammar rule translator by defining clauses for the term_expansion/2 hook predicate.\n", "prefix":"expand_term", "scope":"source.logtalk" }, "methods:findall/3": { "body":"findall(${1:Template}, ${2:Goal}, ${3:List})$0\n", "description":"Template and modes\nfindall(?term, +callable, ?list)\n\nDescription\nCollects a list of solutions for the goal. The order of the elements in the list follows the order of the goal solutions. It succeeds returning an empty list when the goal have no solutions.\n", "prefix":"findall", "scope":"source.logtalk" }, "methods:findall/4": { "body":"findall(${1:Template}, ${2:Goal}, ${3:List}, ${4:Tail})$0\n", "description":"Template and modes\nfindall(?term, +callable, ?list, +list)\n\nDescription\nVariant of the findall/3 method that allows passing the tail of the results list. It succeeds returning the tail argument when the goal have no solutions.\n", "prefix":"findall", "scope":"source.logtalk" }, "methods:forall/2": { "body":"forall(${1:Generator}, ${2:Test})$0\n", "description":"Template and modes\nforall(+callable, +callable)\n\nDescription\nFor all solutions of Generator, Test is true. This built-in meta-predicate is declared as a private method and thus cannot be used as a message to an object.\n", "prefix":"forall", "scope":"source.logtalk" }, "methods:forward/1": { "body":"forward(${1:Message})$0\n", "description":"Template and modes\nforward(+callable)\n\nDescription\nUser-defined method for forwarding unknown messages sent to an object (using the ::/2 control construct), automatically called by the runtime when defined. This method is declared in the forwarding built-in protocol as a public predicate. Note that you can make its scope protected or private by using, respectively, protected or private implementation of the forwarding protocol.\n", "prefix":"forward", "scope":"source.logtalk" }, "methods:goal_expansion/2": { "body":"goal_expansion(${1:Goal}, ${2:ExpandedGoal})$0\n", "description":"Template and modes\ngoal_expansion(+callable, -callable)\n\nDescription\nDefines an expansion for a goal. The first argument is the goal to be expanded. The expanded goal is returned in the second argument. This predicate is called recursively on the expanded goal until a fixed point is reached. Thus, care must be taken to avoid compilation loops. This predicate, when defined and within scope, is automatically called by the expand_goal/2 method. Use of this predicate by the expand_goal/2 method may be restricted by changing its default public scope.\n", "prefix":"goal_expansion", "scope":"source.logtalk" }, "methods:ignore/1": { "body":"ignore(${1:Goal})$0\n", "description":"Template and modes\nignore(+callable)\n\nDescription\nThis predicate succeeds whether its argument succeeds or fails and it is not re-executable. This built-in meta-predicate is declared as a private method and thus cannot be used as a message to an object.\n", "prefix":"ignore", "scope":"source.logtalk" }, "methods:message_hook/4": { "body":"message_hook(${1:Message}, ${2:Kind}, ${3:Component}, ${4:Tokens})$0\n", "description":"Template and modes\nmessage_hook(@nonvar, @nonvar, @nonvar, @list(nonvar))\n\nDescription\nUser-defined hook method for intercepting printing of a message, declared in the logtalk built-in object as a public, multifile, and dynamic predicate. This hook method is automatically called by the print_message/3 method. When the call succeeds, the print_message/3 method assumes that the message have been successfully printed.\n", "prefix":"message_hook", "scope":"source.logtalk" }, "methods:message_prefix_stream/4": { "body":"message_prefix_stream(${1:Kind}, ${2:Component}, ${3:Prefix}, ${4:Stream})$0\n", "description":"Template and modes\nmessage_prefix_stream(?nonvar, ?nonvar, ?atom, ?stream_or_alias)\n\nDescription\nUser-defined hook method for specifying the default prefix and stream for printing a message for a given kind and component. This method is declared in the logtalk built-in object as a public, multifile, and dynamic predicate.\n", "prefix":"message_prefix_stream", "scope":"source.logtalk" }, "methods:message_tokens//2": { "body":"message_tokens(${1:Message}, ${2:Component})$0\n", "description":"Template and modes\nmessage_tokens(+nonvar, +nonvar)\n\nDescription\nUser-defined non-terminal hook used to rewrite a message term into a list of tokens and declared in the logtalk built-in object as a public, multifile, and dynamic non-terminal. The list of tokens can be printed by calling the print_message_tokens/3 method. This non-terminal hook is automatically called by the print_message/3 method.\n", "prefix":"message_tokens", "scope":"source.logtalk" }, "methods:once/1": { "body":"once(${1:Goal})$0\n", "description":"Template and modes\nonce(+callable)\n\nDescription\nThis predicate behaves as call(Goal) but it is not re-executable. This built-in meta-predicate is declared as a private method and thus cannot be used as a message to an object.\n", "prefix":"once", "scope":"source.logtalk" }, "methods:parameter/2": { "body":"parameter(${1:Number}, ${2:Term})$0\n", "description":"Template and modes\nparameter(+integer, ?term)\n\nDescription\nUsed in parametric objects (and parametric categories), this private method provides runtime access to the parameter values of the entity that contains the predicate clause whose body is being executed by using the argument number in the entity identifier. This predicate is implemented as a unification between its second argument and the corresponding implicit execution-context argument in the predicate containing the call. This unification occurs at the clause head when the second argument is not instantiated (the most common case). When the second argument is instantiated, the unification must be delayed to runtime and thus occurs at the clause body. See also this/1.\n", "prefix":"parameter", "scope":"source.logtalk" }, "methods:phrase//1": { "body":"phrase(${1:NonTerminal})$0\n", "description":"Template and modes\nphrase(+callable)\n\nDescription\nThis non-terminal takes a non-terminal or a grammar rule body and parses it using the current implicit list of tokens. A common use is to wrap what otherwise would be a naked variable in a grammar rule body.\n", "prefix":"phrase", "scope":"source.logtalk" }, "methods:phrase/2": { "body":"phrase(${1:GrammarRuleBody}, ${2:Input})$0\n", "description":"Template and modes\nphrase(+callable, ?list)\n\nDescription\nTrue when the GrammarRuleBody grammar rule body can be applied to the Input list of tokens. In the most common case, GrammarRuleBody is a non-terminal defined by a grammar rule. This built-in method is declared private and thus cannot be used as a message to an object. When using a back-end Prolog compiler supporting a module system, calls in the format phrase(Module:GrammarRuleBody, Input) may also be used.\n", "prefix":"phrase", "scope":"source.logtalk" }, "methods:phrase/3": { "body":"phrase(${1:GrammarRuleBody}, ${2:Input}, ${3:Rest})$0\n", "description":"Template and modes\nphrase(+callable, ?list, ?list)\n\nDescription\nTrue when the GrammarRuleBody grammar rule body can be applied to the Input-Rest difference list of tokens. In the most common case, GrammarRuleBody is a non-terminal defined by a grammar rule. This built-in method is declared private and thus cannot be used as a message to an object. When using a back-end Prolog compiler supporting a module system, calls in the format phrase(Module:GrammarRuleBody, Input, Rest) may also be used.\n", "prefix":"phrase", "scope":"source.logtalk" }, "methods:predicate_property/2": { "body":"predicate_property(${1:Predicate}, ${2:Property})$0\n", "description":"Template and modes\npredicate_property(+callable, ?predicate_property)\n\nDescription\nEnumerates, by backtracking, the properties of a visible predicate. When the predicate indicator for Predicate is declared in a uses/2 or use_module/2 directive, properties are enumerated for the referenced object or module predicate. Otherwise properties are enumerated for an object predicate. In the case of objects, properties for predicates not declared using a scope directive are not enumerated. The valid predicate properties are listed in the language grammar.\n", "prefix":"predicate_property", "scope":"source.logtalk" }, "methods:print_message/3": { "body":"print_message(${1:Kind}, ${2:Component}, ${3:Term})$0\n", "description":"Template and modes\nprint_message(+nonvar, +nonvar, +nonvar)\n\nDescription\nBuilt-in method for printing a message represented by a term, which is converted to the message text using the logtalk::message_tokens(Term, Component) hook non-terminal. This method is declared in the logtalk built-in object as a public predicate. The line prefix and the output stream used for each Kind-Component pair can be found using the logtalk::message_prefix_stream(Kind, Component, Prefix, Stream) hook predicate.\n", "prefix":"print_message", "scope":"source.logtalk" }, "methods:print_message_token/4": { "body":"print_message_token(${1:Stream}, ${2:Prefix}, ${3:Token}, ${4:Tokens})$0\n", "description":"Template and modes\nprint_message_token(@stream_or_alias, @atom, @nonvar, @list(nonvar))\n\nDescription\nUser-defined hook method for printing a message token, declared in the logtalk built-in object as a public, multifile, and dynamic predicate. It allows the user to intercept the printing of a message token. This hook method is automatically called by the print_message_tokens/3 built-in method for each token.\n", "prefix":"print_message_token", "scope":"source.logtalk" }, "methods:print_message_tokens/3": { "body":"print_message_tokens(${1:Stream}, ${2:Prefix}, ${3:Tokens})$0\n", "description":"Template and modes\nprint_message_tokens(@stream_or_alias, +atom, @list(nonvar))\n\nDescription\nBuilt-in method for printing a list of message tokens, declared in the logtalk built-in object as a public predicate. This method is automatically called by the print_message/3 method (assuming that the message was not intercepted by a message_hook/4 definition) and calls the user-defined hook predicate print_message_token/4 for each token. When a call to this hook predicate succeeds, the print_message_tokens/3 predicate assumes that the token have been printed. When the call fails, the print_message_tokens/3 predicate uses a default printing procedure for the token.\n", "prefix":"print_message_tokens", "scope":"source.logtalk" }, "methods:question_hook/6": { "body":"question_hook(${1:Question}, ${2:Kind}, ${3:Component}, ${4:Tokens}, ${5:Check}, ${6:Answer})$0\n", "description":"Template and modes\nquestion_hook(+nonvar, +nonvar, +nonvar, +list(nonvar), +callable, -term)\n\nDescription\nUser-defined hook method for intercepting asking a question, declared in the logtalk built-in object as a public, multifile, and dynamic predicate. This hook method is automatically called by the ask_question/5 method. When the call succeeds, the ask_question/5 method assumes that the question have been successfully asked and replied.\n", "prefix":"question_hook", "scope":"source.logtalk" }, "methods:question_prompt_stream/4": { "body":"question_prompt_stream(${1:Kind}, ${2:Component}, ${3:Prompt}, ${4:Stream})$0\n", "description":"Template and modes\nquestion_prompt_stream(?nonvar, ?nonvar, ?atom, ?stream_or_alias)\n\nDescription\nUser-defined hook method for specifying the default prompt and input stream for asking a question for a given kind and component. This method is declared in the logtalk built-in object as a public, multifile, and dynamic predicate.\n", "prefix":"question_prompt_stream", "scope":"source.logtalk" }, "methods:retract/1": { "body":"retract(${1:Head})$0\n", "description":"Template and modes\nretract(+clause)\n\nDescription\nRetracts a clause for a dynamic predicate. When the predicate indicator for Head is declared in a uses/2 or use_module/2 directive, the clause is retracted in the referenced object or module. Otherwise the clause is retracted in an object's dynamic predicate. On backtracking, the predicate retracts the next matching clause.\n", "prefix":"retract", "scope":"source.logtalk" }, "methods:retractall/1": { "body":"retractall(${1:Head})$0\n", "description":"Template and modes\nretractall(+callable)\n\nDescription\nRetracts all clauses with a matching head for a dynamic predicate. When the predicate indicator for Head is declared in a uses/2 or use_module/2 directive, the clauses are retracted in the referenced object or module. Otherwise the clauses are retracted in an object's dynamic predicate.\n", "prefix":"retractall", "scope":"source.logtalk" }, "methods:self/1": { "body":"self(${1:Self})$0\n", "description":"Template and modes\nself(?object_identifier)\n\nDescription\nReturns the object that has received the message under processing. This private method is translated to a unification between its argument and the corresponding implicit context argument in the predicate containing the call. This unification occurs at the clause head when the argument is not instantiated (the most common case).\n", "prefix":"self", "scope":"source.logtalk" }, "methods:sender/1": { "body":"sender(${1:Sender})$0\n", "description":"Template and modes\nsender(?object_identifier)\n\nDescription\nReturns the object that has sent the message under processing. This private method is translated into a unification between its argument and the corresponding implicit context argument in the predicate containing the call. This unification occurs at the clause head when the argument is not instantiated (the most common case).\n", "prefix":"sender", "scope":"source.logtalk" }, "methods:setof/3": { "body":"setof(${1:Template}, ${2:Goal}, ${3:List})$0\n", "description":"Template and modes\nsetof(@term, +callable, -list)\n\nDescription\nCollects a set of solutions for the goal for each set of instantiations of the free variables in the goal. The solutions are sorted using standard term order. The free variables in the goal are the variables that occur in the goal but not in the template. Free variables can be ignored, however, by using the ^/2 existential qualifier. For example, if T is term containing all the free variables that we want to ignore, we can write T^Goal. Note that the term T can be written as V1^V2^....\n", "prefix":"setof", "scope":"source.logtalk" }, "methods:term_expansion/2": { "body":"term_expansion(${1:Term}, ${2:Expansion})$0\n", "description":"Template and modes\nterm_expansion(+nonvar, -nonvar)\nterm_expansion(+nonvar, -list(nonvar))\n\nDescription\nDefines an expansion for a term. This predicate, when defined and within scope, is automatically called by the expand_term/2 method. When that is not the case, the expand_term/2 method only uses the default expansions. Use of this predicate by the expand_term/2 method may be restricted by changing its default public scope.\n", "prefix":"term_expansion", "scope":"source.logtalk" }, "methods:this/1": { "body":"this(${1:This})$0\n", "description":"Template and modes\nthis(?object_identifier)\n\nDescription\nUnifies its argument with the identifier of the object for which the predicate clause whose body is being executed is defined (or the object importing the category that contains the predicate clause). This private method is implemented as a unification between its argument and the corresponding implicit execution-context argument in the predicate containing the call. This unification occurs at the clause head when the argument is not instantiated (the most common case). This method is useful for avoiding hard-coding references to an object identifier or for retrieving all object parameters with a single call when using parametric objects. See also parameter/2.\n", "prefix":"this", "scope":"source.logtalk" }, "methods:throw/1": { "body":"throw(${1:Exception})$0\n", "description":"Template and modes\nthrow(+nonvar)\n\nDescription\nThrows an exception. This built-in predicate is declared as a private method and thus cannot be used as a message to an object.\n", "prefix":"throw", "scope":"source.logtalk" }, "object": { "body":"\n:- object(${1:Prototype},\n\timplements(${2:Protocol}),\n\timports(${3:Category}),\n\textends(${4:Parent})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${5:Author}',\n\t\tdate is ${6:$CURRENT_YEAR}/${7:$CURRENT_MONTH}/${8:$CURRENT_DATE},\n\t\tcomment is '${9:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Prototype with all", "prefix":"object", "scope":"source.logtalk" }, "object1": { "body":"\n:- object(${1:Prototype},\n\timports(${2:Category})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Prototype with category", "prefix":"object", "scope":"source.logtalk" }, "object2": { "body":"\n:- object(${1:Prototype},\n\textends(${2:Parent})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Prototype with parent", "prefix":"object", "scope":"source.logtalk" }, "object3": { "body":"\n:- object(${1:Prototype},\n\timplements(${2:Protocol})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Prototype with protocol", "prefix":"object", "scope":"source.logtalk" }, "object4": { "body":"\n:- object(${1:Object}).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${2:Author}',\n\t\tdate is ${3:$CURRENT_YEAR}/${4:$CURRENT_MONTH}/${5:$CURRENT_DATE},\n\t\tcomment is '${6:Description}'\n\t]).\n\n$0\n\n:- end_object.\n", "description":"Prototype", "prefix":"object", "scope":"source.logtalk" }, "predicates:abolish_category/1": { "body":"abolish_category(${1:Category})$0\n", "description":"Template and modes\nabolish_category(+category_identifier)\n\nDescription\nAbolishes a dynamic category.\n", "prefix":"abolish_category", "scope":"source.logtalk" }, "predicates:abolish_events/5": { "body":"abolish_events(${1:Event}, ${2:Object}, ${3:Message}, ${4:Sender}, ${5:Monitor})$0\n", "description":"Template and modes\nabolish_events(@term, @term, @term, @term, @term)\n\nDescription\nAbolishes all matching events. The two types of events are represented by the atoms before and after. When the predicate is called with the first argument unbound, both types of events are abolished.\n", "prefix":"abolish_events", "scope":"source.logtalk" }, "predicates:abolish_object/1": { "body":"abolish_object(${1:Object})$0\n", "description":"Template and modes\nabolish_object(+object_identifier)\n\nDescription\nAbolishes a dynamic object.\n", "prefix":"abolish_object", "scope":"source.logtalk" }, "predicates:abolish_protocol/1": { "body":"abolish_protocol(${1:Protocol})$0\n", "description":"Template and modes\nabolish_protocol(@protocol_identifier)\n\nDescription\nAbolishes a dynamic protocol.\n", "prefix":"abolish_protocol", "scope":"source.logtalk" }, "predicates:category_property/2": { "body":"category_property(${1:Category}, ${2:Property})$0\n", "description":"Template and modes\ncategory_property(?category_identifier, ?category_property)\n\nDescription\nEnumerates, by backtracking, the properties associated with the defined categories. The valid category properties are listed in the language grammar.\n", "prefix":"category_property", "scope":"source.logtalk" }, "predicates:complements_object/2": { "body":"complements_object(${1:Category}, ${2:Object})$0\n", "description":"Template and modes\ncomplements_object(?category_identifier, ?object_identifier)\n\nDescription\nEnumerates, by backtracking, all category–object pairs such that the category explicitly complements the object.\n", "prefix":"complements_object", "scope":"source.logtalk" }, "predicates:conforms_to_protocol/2-3": { "body":"conforms_to_protocol(${1:Object}, ${2:Protocol})$0\n", "description":"Template and modes\nconforms_to_protocol(?object_identifier, ?protocol_identifier)\nconforms_to_protocol(?category_identifier, ?protocol_identifier)\n\nconforms_to_protocol(?object_identifier, ?protocol_identifier, ?scope)\nconforms_to_protocol(?category_identifier, ?protocol_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, all pairs of entities such that an object or a category conforms to a protocol. The relation scope is represented by the atoms public, protected, and private. This predicate implements a transitive closure for the protocol implementation relation.\n", "prefix":"conforms_to_protocol", "scope":"source.logtalk" }, "predicates:create_category/4": { "body":"create_category(${1:Identifier}, ${2:Relations}, ${3:Directives}, ${4:Clauses})$0\n", "description":"Template and modes\ncreate_category(?category_identifier, +list, +list, +list)\n\nDescription\nCreates a new, dynamic category. This predicate is often used as a primitive to implement high-level category creation methods.\n", "prefix":"create_category", "scope":"source.logtalk" }, "predicates:create_logtalk_flag/3": { "body":"create_logtalk_flag(${1:Flag}, ${2:Value}, ${3:Options})$0\n", "description":"Template and modes\ncreate_logtalk_flag(+atom, +ground, +list(ground))\n\nDescription\nCreates a new Logtalk flag and sets its default value. User-defined flags can be queried and set in the same way as pre-defined flags by using, respectively, the current_logtalk_flag/2 and set_logtalk_flag/2 built-in predicates.\n", "prefix":"create_logtalk_flag", "scope":"source.logtalk" }, "predicates:create_object/4": { "body":"create_object(${1:Identifier}, ${2:Relations}, ${3:Directives}, ${4:Clauses})$0\n", "description":"Template and modes\ncreate_object(?object_identifier, +list, +list, +list)\n\nDescription\nCreates a new, dynamic object. The word object is used here as a generic term. This predicate can be used to create new prototypes, instances, and classes. This predicate is often used as a primitive to implement high-level object creation methods. \n", "prefix":"create_object", "scope":"source.logtalk" }, "predicates:create_protocol/3": { "body":"create_protocol(${1:Identifier}, ${2:Relations}, ${3:Directives})$0\n", "description":"Template and modes\ncreate_protocol(?protocol_identifier, +list, +list)\n\nDescription\nCreates a new, dynamic, protocol. This predicate is often used as a primitive to implement high-level protocol creation methods.\n", "prefix":"create_protocol", "scope":"source.logtalk" }, "predicates:current_category/1": { "body":"current_category(${1:Category})$0\n", "description":"Template and modes\ncurrent_category(?category_identifier)\n\nDescription\nEnumerates, by backtracking, all currently defined categories. All categories are found, either static, dynamic, or built-in.\n", "prefix":"current_category", "scope":"source.logtalk" }, "predicates:current_event/5": { "body":"current_event(${1:Event}, ${2:Object}, ${3:Message}, ${4:Sender}, ${5:Monitor})$0\n", "description":"Template and modes\ncurrent_event(?event, ?term, ?term, ?term, ?object_identifier)\n\nDescription\nEnumerates, by backtracking, all defined events. The two types of events are represented by the atoms before and after.\n", "prefix":"current_event", "scope":"source.logtalk" }, "predicates:current_logtalk_flag/2": { "body":"current_logtalk_flag(${1:Flag}, ${2:Value})$0\n", "description":"Template and modes\ncurrent_logtalk_flag(?atom, ?atom)\n\nDescription\nEnumerates, by backtracking, the current Logtalk flag values.\n", "prefix":"current_logtalk_flag", "scope":"source.logtalk" }, "predicates:current_object/1": { "body":"current_object(${1:Object})$0\n", "description":"Template and modes\ncurrent_object(?object_identifier)\n\nDescription\nEnumerates, by backtracking, all currently defined objects. All objects are found, either static, dynamic or built-in.\n", "prefix":"current_object", "scope":"source.logtalk" }, "predicates:current_protocol/1": { "body":"current_protocol(${1:Protocol})$0\n", "description":"Template and modes\ncurrent_protocol(?protocol_identifier)\n\nDescription\nEnumerates, by backtracking, all currently defined protocols. All protocols are found, either static, dynamic, or built-in.\n", "prefix":"current_protocol", "scope":"source.logtalk" }, "predicates:define_events/5": { "body":"define_events(${1:Event}, ${2:Object}, ${3:Message}, ${4:Sender}, ${5:Monitor})$0\n", "description":"Template and modes\ndefine_events(@term, @term, @term, @term, +object_identifier)\n\nDescription\nDefines a new set of events. The two types of events are represented by the atoms before and after. When the predicate is called with the first argument unbound, both types of events are defined. The object Monitor must define the event handler methods required by the Event argument.\n", "prefix":"define_events", "scope":"source.logtalk" }, "predicates:extends_category/2-3": { "body":"extends_category(${1:Category1}, ${2:Category2})$0\n", "description":"Template and modes\nextends_category(?category_identifier, ?category_identifier)\nextends_category(?category_identifier, ?category_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, all pairs of categories such that the first one extends the second. The relation scope is represented by the atoms public, protected, and private.\n", "prefix":"extends_category", "scope":"source.logtalk" }, "predicates:extends_object/2-3": { "body":"extends_object(${1:Prototype}, ${2:Parent})$0\n", "description":"Template and modes\nextends_object(?object_identifier, ?object_identifier)\nextends_object(?object_identifier, ?object_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, all pairs of objects such that the first one extends the second. The relation scope is represented by the atoms public, protected, and private.\n", "prefix":"extends_object", "scope":"source.logtalk" }, "predicates:extends_protocol/2-3": { "body":"extends_protocol(${1:Protocol1}, ${2:Protocol2})$0\n", "description":"Template and modes\nextends_protocol(?protocol_identifier, ?protocol_identifier)\nextends_protocol(?protocol_identifier, ?protocol_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, all pairs of protocols such that the first one extends the second. The relation scope is represented by the atoms public, protected, and private.\n", "prefix":"extends_protocol", "scope":"source.logtalk" }, "predicates:implements_protocol/2-3": { "body":"implements_protocol(${1:Object}, ${2:Protocol})$0\n", "description":"Template and modes\nimplements_protocol(?object_identifier, ?protocol_identifier)\nimplements_protocol(?category_identifier, ?protocol_identifier)\n\nimplements_protocol(?object_identifier, ?protocol_identifier, ?scope)\nimplements_protocol(?category_identifier, ?protocol_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, all pairs of entities such that an object or a category implements a protocol. The relation scope is represented by the atoms public, protected, and private. This predicate only returns direct implementation relations; it does not implement a transitive closure.\n", "prefix":"implements_protocol", "scope":"source.logtalk" }, "predicates:imports_category/2-3": { "body":"imports_category(${1:Object}, ${2:Category})$0\n", "description":"Template and modes\nimports_category(?object_identifier, ?category_identifier)\n\nimports_category(?object_identifier, ?category_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, importation relations between objects and categories. The relation scope is represented by the atoms public, protected, and private.\n", "prefix":"imports_category", "scope":"source.logtalk" }, "predicates:instantiates_class/2-3": { "body":"instantiates_class(${1:Instance}, ${2:Class})$0\n", "description":"Template and modes\ninstantiates_class(?object_identifier, ?object_identifier)\ninstantiates_class(?object_identifier, ?object_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, all pairs of objects such that the first one instantiates the second. The relation scope is represented by the atoms public, protected, and private.\n", "prefix":"instantiates_class", "scope":"source.logtalk" }, "predicates:logtalk_compile/1": { "body":"logtalk_compile(${1:File})$0\n", "description":"Template and modes\nlogtalk_compile(@source_file_name)\nlogtalk_compile(@list(source_file_name))\n\nDescription\nCompiles to disk a source file or a list of source files using the current default compiler flag values. The Logtalk source file name extension (by default, .lgt) can be omitted. Source file paths can be absolute, relative to the current directory, or use library notation. This predicate can also be used to compile Prolog source files as Logtalk source code. When no recognized Logtalk or Prolog extension is specified, the compiler tries first to append a Logtalk source file extension and then a Prolog source file extension. If that fails, the compiler tries to use the file name as-is.\n", "prefix":"logtalk_compile", "scope":"source.logtalk" }, "predicates:logtalk_compile/2": { "body":"logtalk_compile(${1:File}, ${2:Flags})$0\n", "description":"Template and modes\nlogtalk_compile(@source_file_name, @list(compiler_flag))\nlogtalk_compile(@list(source_file_name), @list(compiler_flag))\n\nDescription\nCompiles to disk a source file or a list of source files using a list of compiler flags. The Logtalk source file name extension (by default, .lgt) can be omitted. Source file paths can be absolute, relative to the current directory, or use library notation. This predicate can also be used to compile Prolog source files as Logtalk source code. When no recognized Logtalk or Prolog extension is specified, the compiler tries first to append a Logtalk source file extension and then a Prolog source file extension. If that fails, the compiler tries to use the file name as-is. Compiler flags are represented as flag(value). For a description of the available compiler flags, please consult the User Manual.\n", "prefix":"logtalk_compile", "scope":"source.logtalk" }, "predicates:logtalk_library_path/2": { "body":"logtalk_library_path(${1:Library}, ${2:Path})$0\n", "description":"Template and modes\nlogtalk_library_path(?atom, -atom)\nlogtalk_library_path(?atom, -compound)\n\nDescription\nDynamic and multifile user-defined predicate, allowing the declaration of aliases to library paths. Library aliases may also be used on the second argument (using the notation alias(path)). Paths must always end with the path directory separator character ('/').\n", "prefix":"logtalk_library_path", "scope":"source.logtalk" }, "predicates:logtalk_load/1": { "body":"logtalk_load(${1:File})$0\n", "description":"Template and modes\nlogtalk_load(@source_file_name)\nlogtalk_load(@list(source_file_name))\n\nDescription\nCompiles to disk and then loads to memory a source file or a list of source files using the current default compiler flag values. The Logtalk source file name extension (by default, .lgt) can be omitted. Source file paths can be absolute, relative to the current directory, or use library notation. This predicate can also be used to compile Prolog source files as Logtalk source code. When no recognized Logtalk or Prolog extension is specified, the compiler tries first to append a Logtalk source file extension and then a Prolog source file extension. If that fails, the compiler tries to use the file name as-is.\n", "prefix":"logtalk_load", "scope":"source.logtalk" }, "predicates:logtalk_load/2": { "body":"logtalk_load(${1:File}, ${2:Flags})$0\n", "description":"Template and modes\nlogtalk_load(@source_file_name, @list(compiler_flag))\nlogtalk_load(@list(source_file_name), @list(compiler_flag))\n\nDescription\nCompiles to disk and then loads to memory a source file or a list of source files using a list of compiler flags. The Logtalk source file name extension (by default, .lgt) can be omitted. Compiler flags are represented as flag(value). This predicate can also be used to compile Prolog source files as Logtalk source code. When no recognized Logtalk or Prolog extension is specified, the compiler tries first to append a Logtalk source file extension and then a Prolog source file extension. If that fails, the compiler tries to use the file name as-is. For a description of the available compiler flags, please consult the User Manual. Source file paths can be absolute, relative to the current directory, or use library notation.\n", "prefix":"logtalk_load", "scope":"source.logtalk" }, "predicates:logtalk_load_context/2": { "body":"logtalk_load_context(${1:Key}, ${2:Value})$0\n", "description":"Template and modes\nlogtalk_load_context(?atom, -nonvar)\n\nDescription\nProvides access to the Logtalk compilation/loading context. The following keys are currently supported: entity_identifier, entity_prefix, entity_type (returns the value module when compiling a module as an object), source, file (the actual file being compiled, which is different from source only when processing an include/1 directive), basename, directory, stream, target (the full path of the intermediate Prolog file), flags (the list of the explicit flags used for the compilation of the source file), term (the term being expanded), term_position (StartLine-EndLine), and variable_names ([Name1=Variable1, ...]). The term_position key is only supported in back-end Prolog compilers that provide access to the start and end lines of a read term.\n", "prefix":"logtalk_load_context", "scope":"source.logtalk" }, "predicates:logtalk_make/0": { "body":"logtalk_make$0$0\n", "description":"Template and modes\nlogtalk_make\n\nDescription\nReloads all Logtalk source files that have been modified since the time they are last loaded. Only source files loaded using the logtalk_load/1-2 predicates are reloaded. Non-modified files will also be reloaded when there is a change to the compilation mode (i.e. when the files were loaded without explicit debug/1 or optimize/1 flags and the default values of these flags changed after loading; no check is made, however, for other implicit compiler flags that may have changed since loading). When an included file is modified, this predicate reloads its main file (i.e. the file that contains the include/1 directive).\n", "prefix":"logtalk_make", "scope":"source.logtalk" }, "predicates:logtalk_make/1": { "body":"logtalk_make(${1:Target})$0\n", "description":"Template and modes\nlogtalk_make(+atom)\n\nDescription\nAllows reloading all Logtalk source files that have been modified since last loaded when called with the target all, deleting all intermediate files generated by the compilation of Logtalk source files when called with the target clean, checking for code issues when called with the target check, and listing of circular dependencies between pairs or trios of objects when called with the target circular.\n", "prefix":"logtalk_make", "scope":"source.logtalk" }, "predicates:object_property/2": { "body":"object_property(${1:Object}, ${2:Property})$0\n", "description":"Template and modes\nobject_property(?object_identifier, ?object_property)\n\nDescription\nEnumerates, by backtracking, the properties associated with the defined objects. The valid object properties are listed in the language grammar.\n", "prefix":"object_property", "scope":"source.logtalk" }, "predicates:protocol_property/2": { "body":"protocol_property(${1:Protocol}, ${2:Property})$0\n", "description":"Template and modes\nprotocol_property(?protocol_identifier, ?protocol_property)\n\nDescription\nEnumerates, by backtracking, the properties associated with the currently defined protocols. The valid protocol properties are listed in the language grammar.\n", "prefix":"protocol_property", "scope":"source.logtalk" }, "predicates:set_logtalk_flag/2": { "body":"set_logtalk_flag(${1:Flag}, ${2:Value})$0\n", "description":"Template and modes\nset_logtalk_flag(+atom, +nonvar)\n\nDescription\nSets Logtalk default, global, flag values. For local flag scope, use the corresponding set_logtalk_flag/2 directive. To set a global flag value when compiling and loading a source file, wrap the calls to this built-in predicate with an initialization/1 directive.\n", "prefix":"set_logtalk_flag", "scope":"source.logtalk" }, "predicates:specializes_class/2-3": { "body":"specializes_class(${1:Class}, ${2:Superclass})$0\n", "description":"Template and modes\nspecializes_class(?object_identifier, ?object_identifier)\nspecializes_class(?object_identifier, ?object_identifier, ?scope)\n\nDescription\nEnumerates, by backtracking, all pairs of objects such that the first one specializes the second. The relation scope is represented by the atoms public, protected, and private.\n", "prefix":"specializes_class", "scope":"source.logtalk" }, "predicates:threaded/1": { "body":"threaded(${1:Goals})$0\n", "description":"Template and modes\nthreaded(+callable)\n\nDescription\nProves each goal in a conjunction (disjunction) of goals in its own thread. This predicate is deterministic and opaque to cuts. The predicate argument is not flattened.\n", "prefix":"threaded", "scope":"source.logtalk" }, "predicates:threaded_call/1-2": { "body":"threaded_call(${1:Goal})$0\n", "description":"Template and modes\nthreaded_call(@callable)\nthreaded_call(@callable, -nonvar)\n\nDescription\nProves Goal asynchronously using a new thread. The argument can be a message sending goal. Calls to this predicate always succeeds and return immediately. The results (success, failure, or exception) are sent back to the message queue of the object containing the call (this); they can be retrieved by calling the threaded_exit/1 predicate.\n", "prefix":"threaded_call", "scope":"source.logtalk" }, "predicates:threaded_engine/1": { "body":"threaded_engine(${1:Engine})$0\n", "description":"Template and modes\nthreaded_engine(?nonvar)\n\nDescription\nEnumerates, by backtracking, all existing engines.\n", "prefix":"threaded_engine", "scope":"source.logtalk" }, "predicates:threaded_engine_create/3": { "body":"threaded_engine_create(${1:AnswerTemplate}, ${2:Goal}, ${3:Engine})$0\n", "description":"Template and modes\nthreaded_engine_create(@term, @callable, ?nonvar)\n\nDescription\nCreates a new engine for proving the given goal and defines an answer template for retrieving the goal solution bindings. A message queue for passing arbitrary terms to the engine is also created. If the name for the engine is not given, a unique name is generated and returned.\n", "prefix":"threaded_engine_create", "scope":"source.logtalk" }, "predicates:threaded_engine_destroy/1": { "body":"threaded_engine_destroy(${1:Engine})$0\n", "description":"Template and modes\nthreaded_engine_destroy(@nonvar)\n\nDescription\nStops an engine.\n", "prefix":"threaded_engine_destroy", "scope":"source.logtalk" }, "predicates:threaded_engine_fetch/1": { "body":"threaded_engine_fetch(${1:Term})$0\n", "description":"Template and modes\nthreaded_engine_fetch(?term)\n\nDescription\nFetches a term from the engine term queue. Blocks until a term is available. Fails in not called from within an engine.\n", "prefix":"threaded_engine_fetch", "scope":"source.logtalk" }, "predicates:threaded_engine_next/2": { "body":"threaded_engine_next(${1:Engine}, ${2:Answer})$0\n", "description":"Template and modes\nthreaded_engine_next(@nonvar, ?term)\n\nDescription\nRetrieves the next answer from an engine. This predicate blocks until an answer becomes available. The predicate fails when there are no more solutions to the engine goal. If the engine goal throws an exception, calling this predicate will re-throw the exception and subsequent calls will fail.\n", "prefix":"threaded_engine_next", "scope":"source.logtalk" }, "predicates:threaded_engine_next_reified/2": { "body":"threaded_engine_next_reified(${1:Engine}, ${2:Answer})$0\n", "description":"Template and modes\nthreaded_engine_next_reified(@nonvar, ?nonvar)\n\nDescription\nRetrieves the next reified answer from an engine. This predicate predicate always succeeds and blocks until an answer becomes available. Answers are returned using the terms the(Answer), no, and exception(Error).\n", "prefix":"threaded_engine_next_reified", "scope":"source.logtalk" }, "predicates:threaded_engine_post/2": { "body":"threaded_engine_post(${1:Engine}, ${2:Term})$0\n", "description":"Template and modes\nthreaded_engine_post(@nonvar, @term)\n\nDescription\nPosts a term to the engine term queue.\n", "prefix":"threaded_engine_post", "scope":"source.logtalk" }, "predicates:threaded_engine_self/1": { "body":"threaded_engine_self(${1:Engine})$0\n", "description":"Template and modes\nthreaded_engine_self(?nonvar)\n\nDescription\nQueries the name of engine calling the predicate.\n", "prefix":"threaded_engine_self", "scope":"source.logtalk" }, "predicates:threaded_engine_yield/1": { "body":"threaded_engine_yield(${1:Answer})$0\n", "description":"Template and modes\nthreaded_engine_yield(@term)\n\nDescription\nReturns an answer independent of the solutions of the engine goal. Fails if not called from within an engine. This predicate is usually used when the engine goal is call to a recursive predicate processing terms from the engine term queue.\n", "prefix":"threaded_engine_yield", "scope":"source.logtalk" }, "predicates:threaded_exit/1-2": { "body":"threaded_exit(${1:Goal})$0\n", "description":"Template and modes\nthreaded_exit(+callable)\nthreaded_exit(+callable, +nonvar)\n\nDescription\nRetrieves the result of proving Goal in a new thread. This predicate blocks execution until the reply is sent to the this message queue by the thread executing the goal. When there is no thread proving the goal, the predicate generates an exception. This predicate is non-deterministic, providing access to any alternative solutions of its argument.\n", "prefix":"threaded_exit", "scope":"source.logtalk" }, "predicates:threaded_ignore/1": { "body":"threaded_ignore(${1:Goal})$0\n", "description":"Template and modes\nthreaded_ignore(@callable)\n\nDescription\nProves Goal asynchronously using a new thread. Only the first goal solution is found. The argument can be a message sending goal. This call always succeeds, independently of the result (success, failure, or exception), which is simply discarded instead of being sent back to the message queue of the object containing the call (this).\n", "prefix":"threaded_ignore", "scope":"source.logtalk" }, "predicates:threaded_notify/1": { "body":"threaded_notify(${1:Term})$0\n", "description":"Template and modes\nthreaded_notify(@term)\nthreaded_notify(@list(term))\n\nDescription\nSends Term as a notification to any thread suspended waiting for it in order to proceed. The call must be made within the same object (this) containing the calls to the threaded_wait/1 predicate waiting for the notification. The argument may also be a list of notifications, [Term| Terms]. In this case, all notifications in the list will be sent to any threads suspended waiting for them in order to proceed.\n", "prefix":"threaded_notify", "scope":"source.logtalk" }, "predicates:threaded_once/1-2": { "body":"threaded_once(${1:Goal})$0\n", "description":"Template and modes\nthreaded_once(@callable)\nthreaded_once(@callable, -nonvar)\n\nDescription\nProves Goal asynchronously using a new thread. Only the first goal solution is found. The argument can be a message sending goal. This call always succeeds. The result (success, failure, or exception) is sent back to the message queue of the object containing the call (this).\n", "prefix":"threaded_once", "scope":"source.logtalk" }, "predicates:threaded_peek/1-2": { "body":"threaded_peek(${1:Goal})$0\n", "description":"Template and modes\nthreaded_peek(+callable)\nthreaded_peek(+callable, +nonvar)\n\nDescription\nChecks if the result of proving Goal in a new thread is already available. This call succeeds or fails without blocking execution waiting for a reply to be available.\n", "prefix":"threaded_peek", "scope":"source.logtalk" }, "predicates:threaded_wait/1": { "body":"threaded_wait(${1:Term})$0\n", "description":"Template and modes\nthreaded_wait(?term)\nthreaded_wait(+list(term))\n\nDescription\nSuspends the thread making the call until a notification is received that unifies with Term. The call must be made within the same object (this) containing the calls to the threaded_notify/1 predicate that will eventually send the notification. The argument may also be a list of notifications, [Term| Terms]. In this case, the thread making the call will suspend until all notifications in the list are received.\n", "prefix":"threaded_wait", "scope":"source.logtalk" }, "private": { "body":"\t:- private(${1:Functor}/0).\n\t:- mode(${1:Functor}, ${2:Solutions}).\n\t:- info(${1:Functor}/0, [\n\t\tcomment is '${3:Description}'\n\t]).\n\n$0", "description":"(with no arguments)", "prefix":"private", "scope":"source.logtalk" }, "private1": { "body":"\t:- private(${1:Functor}/${2:Arity}).\n\t:- mode(${1:Functor}(${3:Arguments}), ${4:Solutions}).\n\t:- info(${1:Functor}/${2:Arity}, [\n\t\tcomment is '${5:Description}',\n\t\targuments is ['$6'-'$7']\n\t]).\n\n$0", "description":"Private predicate", "prefix":"private", "scope":"source.logtalk" }, "protected": { "body":"\t:- protected(${1:Functor}/0).\n\t:- mode(${1:Functor}, ${2:Solutions}).\n\t:- info(${1:Functor}/0, [\n\t\tcomment is '${3:Description}'\n\t]).\n\n$0", "description":"(with no arguments)", "prefix":"protected", "scope":"source.logtalk" }, "protected1": { "body":"\t:- protected(${1:Functor}/${2:Arity}).\n\t:- mode(${1:Functor}(${3:Arguments}), ${4:Solutions}).\n\t:- info(${1:Functor}/${2:Arity}, [\n\t\tcomment is '${5:Description}',\n\t\targuments is ['$6'-'$7']\n\t]).\n\n$0", "description":"Protected predicate", "prefix":"protected", "scope":"source.logtalk" }, "protocol": { "body":"\n:- protocol(${1:Extended},\n\textends(${2:Minimal})).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${3:Author}',\n\t\tdate is ${4:$CURRENT_YEAR}/${5:$CURRENT_MONTH}/${6:$CURRENT_DATE},\n\t\tcomment is '${7:Description}'\n\t]).\n\n$0\n\n:- end_protocol.\n", "description":"Extended protocol", "prefix":"protocol", "scope":"source.logtalk" }, "protocol1": { "body":"\n:- protocol(${1:Protocol}).\n\n\t:- info([\n\t\tversion is 1.0,\n\t\tauthor is '${2:Author}',\n\t\tdate is ${3:$CURRENT_YEAR}/${4:$CURRENT_MONTH}/${5:$CURRENT_DATE},\n\t\tcomment is '${6:Description}'\n\t]).\n\n$0\n\n:- end_protocol.\n", "description":"Protocol", "prefix":"protocol", "scope":"source.logtalk" }, "public": { "body":"\t:- public(${1:Functor}/0).\n\t:- mode(${1:Functor}, ${2:Solutions}).\n\t:- info(${1:Functor}/0, [\n\t\tcomment is '${3:Description}'\n\t]).\n\n$0", "description":"(with no arguments)", "prefix":"public", "scope":"source.logtalk" }, "public1": { "body":"\t:- public(${1:Functor}/${2:Arity}).\n\t:- mode(${1:Functor}(${3:Arguments}), ${4:Solutions}).\n\t:- info(${1:Functor}/${2:Arity}, [\n\t\tcomment is '${5:Description}',\n\t\targuments is ['$6'-'$7']\n\t]).\n\n$0", "description":"Public predicate", "prefix":"public", "scope":"source.logtalk" } }